spring框架案例学习文档笔记.docx
《spring框架案例学习文档笔记.docx》由会员分享，可在线阅读，更多相关《spring框架案例学习文档笔记.docx（70页珍藏版）》请在冰豆网上搜索。
spring框架案例学习文档笔记
Spring–SSH整合学习笔记
---wjt276
[2010-05-14]
目录
第一课：
面向抽象编程4
第二课：
Jdom的基本使用4
第三课：
模拟Spring功能5
第四课：
搭建sping的运行环境8
一、建立一个新的项目8
二、建立spring的配置文件8
三、引入spring的jar包8
四、测试代码：
8
五、注意接口的使用：
8
第五课：
IOC（DI）配置及应用9
一、什么是IOC、DI9
二、编辑xml文件时，没有提示9
三、注入类型（Injectingdependencies）9
（一）setter注入类型SetterInjection9
（二）构造方法ConstructorInjection10
四、id、name11
五、简单属性的注入11
六、Bean的作用范围scope12
七、集合注入12
八、自动装配autowire13
（一）byName13
（二）byType14
（三）注意14
九、生命周期15
（一）lazy-init/default-lazy-init15
（二）init-methoddestroy-method不要和prototype一起用（了解）15
第六课：
annotation方式Spring16
一、开始使用annotation配置Spring16
二、@Autowired、@Qualifier16
（一）@Autowired16
（二）@Qualifier17
三、@Resource（重要、推荐）17
（一）JSR-25017
（二）@Resource17
四、@Componet18
五、@Scope、@PostConstruct、@PreDestroy19
六、注解对应的jar包19
第七课：
AOP（面向切面编程）19
一、AOP概念19
二、利用动态代理实现面向切面编程20
第八课：
SpringAOP配置选项21
一、AOP配置annotation方式21
（一）搭建annotation开发环境21
（二）aspectJ类库22
（三）AOP的annotation实例22
（四）AspectJ的专业术语23
（五）织入点语法23
（六）Advice24
（七）Pointcut26
（八）annotatin方式的AOP实例26
二、AOP配置xml方式27
三、AOP实现动态代理注意28
第九课：
DataSource28
一、Sping配置数据源：
28
二、注入使用29
三、dbcp.BasicDataSource29
第十课Spring整合Hiberante330
一、Spring配置hibernate3的SessionFactory30
（一）xml形式的SessionFactory30
（二）annotation注解方式的SessionFactory30
二、引入hibernate所需要使用的jar31
（一）基本jar31
（二）加入annotation功能的jar包31
（三）搭建日志环境并配置显示DDL语句jar包31
三、Spring整合hibernate3事务31
（一）Annotation注解方式配置事务管理31
（二）Spring事务选项35
（三）XML文件形式配置Spring事务管理37
四、HibernateTemplate38
（一）HibernateTemplate38
（二）HibernateDaoSupport39
第十一课：
Spring整合-SSH40
一、第一步：
加入jar包（需要的jar包列表）40
二、第二步：
首先整合Spring+Hibernate41
三、第三步：
再来整合Struts241
四、struts的读常量：
43
第十二课：
DTO、VO43
一、DTO43
二、VO43
第十二课：
SSH整合存在的问题43
一、Jsp中访问Session时，Session已经关闭43
二、如果不配置事务，openSessionView出现异常44
三、中文乱码问题：
44
第十三课：
SSH整合的jar包45
一、Struts245
二、Hibernate3.3.245
三、Spring46
第一课：
面向抽象编程
原来什么类都是写死的，现在是先建立一个大的标准，然后再各个实体类来实现他们的功能，然后在调用的时候，使用这个标准调用，这样，你们那个来都可以被调用。
实例：
User实体类
publicclassUser{
privateStringusername;
privateStringpassword;
publicStringgetUsername（）{returnusername;}
publicvoidsetUsername（Stringusername）{this.username=username;}
publicStringgetPassword（）{returnpassword;}
publicvoidsetPassword（Stringpassword）{
this.password=password;
}}
UserDao接口
publicinterfaceUserDao{
publicvoidsave（Useru）;
}
UserDao的实现UserDaoImpl
publicclassUserDaoImplimplementsUserDao{
@Override
publicvoidsave（Useru）{
System.out.println（"usersave..."）;
}}
User管理类
publicclassUserService{
//这里需要什么的实现，在new时，就new什么的实现，在调用方法时，会调用具体的实现类的方法
privateUserDaouserDao=newUserDaoImpl（）;
publicUserDaogetUserDao（）{returnuserDao;}
publicvoidsetUserDao（UserDaouserDao）{this.userDao=userDao;}
publicvoidadd（Useru）{
userDao.save（u）;}//这里可以调用任务实现了UserDao接口的save方法了。
}
第二课：
Jdom的基本使用
test.xml
xmlversion="1.0"encoding="UTF-8"?
>
8G
200
1580
10G
500
3000
实例类：
publicclassSample1{
publicstaticvoidmain（String[]args）throwsException{
SAXBuildersb=newSAXBuilder（）;//创建一个SAXBuilder对象
Documentdoc=
sb.build（Sample1.class.getClassLoader（）.getResourceAsStream（"test.xml"））;
//构造文档对象
Elementroot=doc.getRootElement（）;//获取根元素
Listlist=root.getChildren（"disk"）;//取名字为disk的所有元素
for（inti=0;iElementelement=（Element）list.get（i）;
Stringname=element.getAttributeValue（"name"）;//获取元素中属性为name的值
Stringcapacity=element.getChildText（"capacity"）;//取disk子元素capacity的内容
Stringdirectories=element.getChildText（"directories"）;
Stringfiles=element.getChildText（"files"）;
System.out.println（"磁盘信息:
"）;
System.out.println（"分区盘符:
"+name）;
System.out.println（"分区容量:
"+capacity）;
System.out.println（"目录数:
"+directories）;
System.out.println（"文件数:
"+files）;
System.out.println（"-----------------------------------"）;
}}}
第三课：
模拟Spring功能
因为Spring是使用xml配置文件来实现的，所以我们首先模拟一个xml的配置文件如下：
beans.xml
实现的功能：
当类初始化时，
一、程序会根据此配置文件初始化文件所有的bean元素所代表的类，放入一个容器中（使用Map），然后在需要时，会根据ID值，取出这个对象；
1、代码：
publicclassClassPathXmlApplicationContextimplementsBeanFactory{
privateMapbeans=newHashMap（）;
publicClassPathXmlApplicationContext（）throwsException{
SAXBuildersb=newSAXBuilder（）;//创建一个SAXBuilder对象
Documentdoc=sb.build（ClassPathXmlApplicationContext.class.getClassLoader（）.getResourceAsStream（"beans.xml"））;//构造文档对象
Elementroot=doc.getRootElement（）;//获取根元素
//System.out.println（root.getName（））;
Listlist=root.getChildren（"bean"）;//取名字为disk的所有元素
for（inti=0;iElementelement=（Element）list.get（i）;
Stringid=element.getAttributeValue（"id"）;
Stringclazz=element.getAttributeValue（"class"）;
System.out.println（id+":
"+clazz）;
Objecto=Class.forName（clazz）.newInstance（）;
beans.put（id,o）;
}
}
publicObjectgetBean（Stringname）{
returnbeans.get（name）;
}
}
2、测试：
BeanFactoryfactory=newClassPathXmlApplicationContext（）;
UserServiceservice=newUserService（）;
//UserServiceservice=（UserService）factory.getBean（"userService"）;
UserDaouserDao=（UserDao）factory.getBean（"u"）;//此得只需要根据ID就可以取得Bean对象来使用
service.setUserDao（userDao）;
Useru=newUser（）;
service.add（u）;
二、当某一bean元素下存在property子元素时，则需要把这个子元素作为参数自动注入（使用setXXX方法）到这个bean对象中
1、代码：
publicclassClassPathXmlApplicationContextimplementsBeanFactory{
privateMapbeans=newHashMap（）;
publicClassPathXmlApplicationContext（）throwsException{
SAXBuildersb=newSAXBuilder（）;//创建一个SAXBuilder对象
Documentdoc=sb.build（ClassPathXmlApplicationContext.class.getClassLoader（）.getResourceAsStream（"beans.xml"））;//构造文档对象
Elementroot=doc.getRootElement（）;//获取根元素
Listlist=root.getChildren（"bean"）;//取名字为disk的所有元素
for（inti=0;iElementelement=（Element）list.get（i）;
Stringid=element.getAttributeValue（"id"）;
Stringclazz=element.getAttributeValue（"class"）;
System.out.println（id+":
"+clazz）;
Objecto=Class.forName（clazz）.newInstance（）;
beans.put（id,o）;
//*以下for循环是实现模拟spring自动装配（注入）功能
//一开始列出此bean的所有property子元素
for（ElementpropertyElement:
（List）element.getChildren（"property"））{
//获取property子元素中属性为name的值（也就是需要注入的参数名称）
Stringname=propertyElement.getAttributeValue（"name"）;
//获取property子元素中属性为bean的值（需要注入参数的类型）,此处的bean值是已经在上面初始化好了的bean的ID了。
Stringbean=propertyElement.getAttributeValue（"bean"）;
//因此此处获取指定ID的bean
ObjectbeanObject=beans.get（bean）;
//组成set方法名称：
set+第一个字母大写+其它的字母
StringmethodName="set"+name.substring（0,1）.toUpperCase（）+name.substring
（1）;
System.out.println（"methodName="+methodName）;
//获取bean的set方法，参数（方法名，参数：
此参数的类型）
Methodm=o.getClass（）.getMethod（methodName,beanObject.getClass（）.getInterfaces（）[0]）;
//使用反映机制，执行method方法，从而实现注入功能
m.invoke（o,beanObject）;
}
}
}
publicObjectgetBean（Stringname）{
returnbeans.get（name）;
}
}
注意，以上有背景色的部分是实现自动装配（注入）的代码。
2、测试
publicvoidtestAdd_3（）throwsException{
BeanFactoryfactory=newClassPathXmlApplicationContext（）;
UserServiceservice=（UserService）factory.getBean（"userService"）;
//以下两行代码在实现注入功能后，将不再需要，因为程序在加载时，已经帮我自动注入这个参数了。
//UserDaouserDao=（UserDao）factory.getBean（"u"）;
//service.setUserDao（userDao）;
Useru=newUser（）;
service.add（u）;
}
BeanFactory接口代码：
publicinterfaceBeanFactory{
publicObjectgetBean（Stringname）;
}
第四课：
搭建sping的运行环境
一、建立一个新的项目
a）建立新的项目；
b）建立需要的bean类
二、建立spring的配置文件
你可以在spring文件中复制代码
xmlversion="1.0"encoding="UTF-8"?
>
//www.springframework.org/schema/beans"
xmlns:
xsi="http:
//www.w3.org/2001/XMLSchema-instance"
xsi:
schemaLocation="http:
//www.springframework.org/schema/beans
http:
//www.springframework.org/schema/beans/spring-beans-2.5.xsd">
--这里的ref表示参考那个bean-->
--或是下面的方式
-->
三、引入spring的jar包
可以建立一个UserLibrary
搭建spring环境基本的包：
spring.jar和commons-logging.jar
四、测试代码：
publicvoidtestAdd_3（）throwsException{
BeanFactoryfactory=newClassPathXmlApplicationContext（"beans.xml"）;
UserServiceservice=（UserService）factory.getBean（"userService"）;
Useru=newUser（）;
service.add（u）;
}
注意：
这里使用的ClassPathXmlApplicationContext和BeanFactory是spring的，如下：
importorg.springframework.beans.factory.BeanFactory;
importorg.springframework.context.support.ClassPathXmlApplicationContext;
五、注意接口的使用：
ClassPathXmlApplicationContext类实现了ApplicationContext接口，而ApplicationContext接口又实现了BeanFactory接口，这样BeanFactory是根上的接口。
一般建议使用ApplicationContext接口，因为：
1、BeanFactory:
只是完成Bean工厂的基本功能，不能完成bean的生命周期
2、ApplicationContext：
除了完成bean工厂的基本功能外，还完成的其它的附加功能（比如：
bean的生命周期），也就是功能更强大
这样上面的代码就是
publicvoidtestAdd_3（）throwsException{
ApplicationContextfactory=newClassPathXmlApplicationContext（"beans.xml"）;
UserServiceservice=（UserService）factory.getBean（"userService"）;
Useru=newUser（）;
service.add（u）;
}
第五课：
IOC（DI）配置及应用
一、什么是IOC、DI
IOC:
InversionofControl控制反转：
原来类的一些成员属性（例如UserService中的userDao成员属性）是由当前类（UserService）自己控制，现在不是由当前类（UserService）自己控制，而是由容器（运行环境上下文、Spring）帮我们来控制。
还是一种说法：
原来我们自己控制是控制
升级会员 