spring框架案例学习文档笔记

Spring–SSH整合学习笔记wjt276[2023-05-14]目录第一课：面向抽象编程 4第二课：Jdom的基本使用 4第三课：模拟Spring功能 5第四课：搭建sping的运营环境 8一、 建立一个新的项目 8二、 建立spring的配置文献 8三、 引入spring的jar包 8四、 测试代码： 8五、 注意接口的使用： 8第五课：IOC(DI)配置及应用 9一、 什么是IOC、DI 9二、 编辑xml文献时，没有提醒 9三、 注入类型(Injectingdependencies) 9(一) setter注入类型SetterInjection 9(二) 构造方法ConstructorInjection 10四、 id、name 11五、 简朴属性的注入 11六、 Bean的作用范围scope 12七、 集合注入 12八、 自动装配autowire 13(一) byName 13(二) byType 14(三) 注意 14九、 生命周期 15(一) lazy-init/default-lazy-init 15(二) init-methoddestroy-method不要和prototype一起用（了解） 15第六课：annotation方式Spring 16一、 开始使用annotation配置Spring 16二、 @Autowired、@Qualifier 16(一) @Autowired 16(二) @Qualifier 17三、 @Resource(重要、推荐) 17(一) JSR-250 17(二) @Resource 17四、 @Componet 18五、 @Scope、@PostConstruct、@PreDestroy 19六、 注解相应的jar包 19第七课：AOP(面向切面编程) 19一、 AOP概念 19二、 运用动态代理实现面向切面编程 20第八课：SpringAOP配置选项 21一、 AOP配置annotation方式 21(一) 搭建annotation开发环境 21(二) aspectJ类库 22(三) AOP的annotation实例 22(四) AspectJ的专业术语 23(五) 织入点语法 23(六) Advice 24(七) Pointcut 26(八) annotatin方式的AOP实例 26二、 AOP配置xml方式 27三、 AOP实现动态代理注意 28第九课：DataSource 28一、 Sping配置数据源： 28二、 注入使用 29三、 dbcp.BasicDataSource 29第十课Spring整合Hiberante3 30一、 Spring配置hibernate3的SessionFactory 30(一) xml形式的SessionFactory 30(二) annotation注解方式的SessionFactory 30二、 引入hibernate所需要使用的jar 31(一) 基本jar 31(二) 加入annotation功能的jar包 31(三) 搭建日记环境并配置显示DDL语句jar包 31三、 Spring整合hibernate3事务 31(一) Annotation注解方式配置事务管理 31(二) Spring事务选项 35(三) XML文献形式配置Spring事务管理 37四、 HibernateTemplate 38(一) HibernateTemplate 38(二) HibernateDaoSupport 39第十一课：Spring整合-SSH 40一、 第一步：加入jar包(需要的jar包列表) 40二、 第二步：一方面整合Spring+Hibernate 41三、 第三步：再来整合Struts2 41四、 struts的读常量： 43第十二课：DTO、VO 43一、 DTO 43二、 VO 43第十二课：SSH整合存在的问题 43一、 Jsp中访问Session时，Session已经关闭 43二、 假如不配置事务，openSessionView出现异常 44三、 中文乱码问题： 44第十三课：SSH整合的jar包 45一、 Struts2 45二、 Hibernate3.3.2 45三、 Spring 46

第一课：面向抽象编程本来什么类都是写死的，现在是先建立一个大的标准，然后再各个实体类来实现他们的功能，然后在调用的时候，使用这个标准调用，这样，你们那个来都可以被调用。实例：User实体类publicclassUser{ privateStringusername; privateStringpassword; publicStringgetUsername(){ returnusername; } publicvoidsetUsername(Stringusername){this.username=username;} publicStringgetPassword(){returnpassword; } publicvoidsetPassword(Stringpassword){ this.password=password; }}UserDao接口publicinterfaceUserDao{ publicvoidsave(Useru);}UserDao的实现UserDaoImplpublicclassUserDaoImplimplementsUserDao{ @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"?><HD><diskname="C"><capacity>8G</capacity><directories>200</directories><files>1580</files></disk><diskname="D"><capacity>10G</capacity><directories>500</directories><files>3000</files></disk></HD>实例类：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;i<list.size();i++){Elementelement=(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<beans> <beanid="u"class="com.wjt276.dao.impl.UserDaoImpl"/> <beanid="userService"class="com.wjt276.service.UserService"> <propertyname="userDao"bean="u"/> </bean></beans>实现的功能：当类初始化时，程序会根据此配置文献初始化文献所有的bean元素所代表的类，放入一个容器中(使用Map)，然后在需要时，会根据ID值，取出这个对象；代码：publicclassClassPathXmlApplicationContextimplementsBeanFactory{ privateMap<String,Object>beans=newHashMap<String,Object>(); 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;i<list.size();i++){ Elementelement=(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); }}测试：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对象中代码：publicclassClassPathXmlApplicationContextimplementsBeanFactory{ privateMap<String,Object>beans=newHashMap<String,Object>(); 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;i<list.size();i++){ Elementelement=(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>)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);}}注意，以上有背景色的部分是实现自动装配(注入)的代码。测试 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的运营环境建立一个新的项目建立新的项目；建立需要的bean类建立spring的配置文献你可以在spring文献中复制代码<?xmlversion="1.0"encoding="UTF-8"?><beansxmlns=""xmlns:xsi=""xsi:schemaLocation=""><beanid="u"class="com.wjt276.dao.impl.UserDaoImpl"></bean><beanid="userService"class="com.wjt276.service.UserService"> <propertyname="userDao"ref="u"/><!--这里的ref表达参考那个bean--> <!--或是下面的方式 <propertyname="userDao"> <refbean="u"></ref> </property> --></bean></beans>引入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、DIIOC:InversionofControl控制反转：本来类的一些成员属性(例如UserService中的userDao成员属性)是由当前类(UserService)自己控制，现在不是由当前类(UserService)自己控制，而是由容器(运营环境上下文、Spring)帮我们来控制。还是一种说法：本来我们自己控制是控制实现，而现在Spring是运用接口来控制的。所以我们由本来控制实现转为springg现在来控制接口(向上反转)作用：实例化具体的bean 动态装配bean(本来是由我来控制的，现在我交给容器来控制。)DI:DependencyInjection依赖注入：一些成员属性(例如UserService中的userDao成员属性)依赖Spring容器来注入好处：偶合性相对来减少了；此外，注入是使用配置文献来实现，这样修改来非常的方便. DI与IOC相对来说是同样的概念。编辑xml文献时，没有提醒window–preferences–myeclipse–FilesandEditing-xml–xmlcatalogadd按钮Location: D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\spring-beans-2.5.xsdURI: file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resources/spring-beans-2.5.xsdKeyType: SchemaLocationKey: 注入类型(Injectingdependencies)setter(重要)构造方法(使用的非常少)接口注入(可以忘掉)setter注入类型SetterInjection 就是在bean中使用setXXX方法进行注入来 在bean类中，成员属性需要setXXX方法如下：publicclassUserService{ privateUserDaouserDao=newUserDaoImpl(); publicUserDaogetUserDao(){ returnuserDao; } publicvoidsetUserDao(UserDaouserDao){ this.userDao=userDao; } publicvoidadd(Useru){ userDao.save(u);}}spring配置文献如下：<beanid="u"class="com.wjt276.dao.impl.UserDaoImpl"></bean><beanid="userService"class="com.wjt276.service.UserService"> <propertyname="userDao"ref="u"/><!--这里的ref表达参考id=u的那个bean--> <!--或是下面的方式 <propertyname="userDao"> <refbean="u"></ref> </property>--></bean>构造方法ConstructorInjection一方面在bean类中需要有成员属性作为参数的构造方法 代码如下：publicclassUserService{ privateUserDaouserDao=newUserDaoImpl(); publicUserService(UserDaouserDao){ super(); this.userDao=userDao; } publicUserDaogetUserDao(){returnuserDao;} publicvoidsetUserDao(UserDaouserDao){ this.userDao=userDao;} publicvoidadd(Useru){ userDao.save(u);}}注意：背景较深的代码为构造方法，带有参数的构造方法spring配置文献如下：<beanid="u"class="com.wjt276.dao.impl.UserDaoImpl"></bean><beanid="userService"class="com.wjt276.service.UserService"> <constructor-arg> <beanclass="com.wjt276.dao.impl.UserDaoImpl"></bean> <!--<refbean="u"/>--> <!-- 需要注意的： 使用<bean>表达，重新new一个bean然后注入进去， 使用<ref>表达，使用已经new好的bean,这是只是引用它。 --> </constructor-arg></bean>使用<constructor-arg>和其子标签<bean>或<ref>进行构造方法注入当构造方法注入时，构造方法中有多个参数时，可以使用以下两种方式注入：bean代码：publicclassExampleBean{privateintyears;privateStringultimateAnswer;publicExampleBean(intyears,StringultimateAnswer){this.years=years;this.ultimateAnswer=ultimateAnswer;}}1、参数类型方式进行区分参数：xml配置文献：<beanid="exampleBean"class="examples.ExampleBean"> <constructor-argtype="int"value="7500000"/><constructor-argtype="java.lang.String"value="42"/></bean>注意：这样就是参数类型为int的注入7500000,而参数类型为java.lang.String的参数注入”42”,但这个方法不适合多个参数是相同的类型。2、运用索引进行区分参数xml配置文献<beanid="exampleBean"class="examples.ExampleBean"><constructor-argindex="0"value="7500000"/><constructor-argindex="1"value="42"/></bean>注意：index=0的注入到第一个参数，index=1的注入到第二个参数。构造方法的注入不方便，所以我们需要使用setter注入方式。id、name注xml配置文献中<bean>标签中的属性名称如下：<beanid="u"class="com.wjt276.dao.impl.UserDaoImpl"></bean>或<beanname="u"class="com.wjt276.dao.impl.UserDaoImpl"></bean>以上标签中的属性id与name作用是同样，唯一的区别：id中不可以具有特殊字符，而name中可以有特殊字符简朴属性的注入当bean中存在简朴属性时的注入方式：bean代码如下：publicclassUserDaoImplimplementsUserDao{ privateintdaoId; privateStringdaoStatus; publicintgetDaoId(){returndaoId;} publicvoidsetDaoId(intdaoId){this.daoId=daoId; } publicStringgetDaoStatus(){ returndaoStatus; } publicvoidsetDaoStatus(StringdaoStatus){this.daoStatus=daoStatus;} @Override publicvoidsave(Useru){System.out.println("usersave...");}}xml配置文献如下：<beanid="u"class="com.wjt276.dao.impl.UserDaoImpl"> <propertyname="daoId"value="8"></property> <propertyname="daoStatus"> <value>good</value> </property></bean>直接使用value属性或是<value>子标签来注入Bean的作用范围scope在Spring配置文献中的<bean>标签可以指定bean的作用范围运用<bean>标签中的scope属性来指定scope值：singleton单例：每次取出的bean都是同一个bean。默认就是这个prototype原型：每次取的bean时，都会重新创建一个新的beanrequestsessionglobalsession实例：<beanid="u"class="com.wjt276.dao.impl.UserDaoImpl"></bean><beanname="userService"class="com.wjt276.service.UserService"scope="prototype"> <propertyname="userDao"ref="u"/> </bean>注意：只有spring与web框架结合时才会使用request/session/globalsession，但也非常少用，由于其它框架已有功能非常强大的scope了(例如：struts的scope)集合注入很少用，不重要，参考程序<beanid="u"class="com.wjt276.dao.impl.UserDaoImpl"> <propertyname="properties"> <props> <propkey="administrator"></prop> <propkey="support"></prop> <propkey="development"></prop> </props> </property> <propertyname="list"> <list> <value>alistelementfollowedbyareference</value> <refbean="myDataSource"/> </list> </property> <propertyname="map"> <map> <entry> <key> <value>anentry</value> </key> <value>justsomestring</value> </entry> <entry> <key> <value>aref</value> </key> <refbean="myDataSource"/> </entry> </map> </property> <propertyname="set"> <set> <value>justsomestring</value> <refbean="myDataSource"/> </set> </property> </bean>自动装配autowire含义：在bean注入时不需要我们来指定注入哪个具体的bean，而spring容器会根据我的使用autowire属性来拟定自动装配功能。autowire值：autodetect;byName:根据bean中成员属性的名称来自动装配byType：根据bean中成员属性的类型来自动装配。constaractordefault：会根据<beans>标签中的default-autowire属性来进行自动装配的方式no(默认就是这个，需要手动指定注入那个bean)byName根据bean中成员属性的名称来自动装配。bean代码：UserDaoImpl类publicclassUserDaoImplimplementsUserDao{ privateintdaoId; publicintgetDaoId(){returndaoId;} publicvoidsetDaoId(intdaoId){this.daoId=daoId; } @Override publicStringtoString(){ return"daoId="+this.daoId; }}UserService类publicclassUserService{ privateUserDaouserDao=newUserDaoImpl(); publicUserDaogetUserDao(){ returnuserDao; } publicvoidsetUserDao(UserDaouserDao){ this.userDao=userDao; } publicvoidadd(Useru){ userDao.save(u); }}spring的配置文献<beanid="userDao"class="com.wjt276.dao.impl.UserDaoImpl"> <propertyname="daoId"value="1"></property></bean><beanid="userDao2"class="com.wjt276.dao.impl.UserDaoImpl"> <propertyname="daoId"value="2"></property></bean><beanname="userService"class="com.wjt276.service.UserService"scope="prototype"autowire="byName"></bean>测试代码： publicvoidtestAdd_4()throwsException{ ApplicationContextfactory=newClassPathXmlApplicationContext("beans.xml"); UserServiceservice=(UserService)factory.getBean("userService"); System.out.println(service.getUserDao()); }结果：daoId=1说明：由于在配置文献中配置了两个UserDaoImpl(名称分别：userDao、userDao2)和一个UserService类。而在userService的bean中并没有进行注入配置。而是使用了autowire属性指定了byName值，这样结果是对的的，是由于spring看到autowire=byName后，会在配置文献中查找bean的id与userService成员属性名称一至，然后将其注入，这样就完毕了根据名称自动装配功能。byType根据类型自动装配：就是spring在初始化时，会在配置文献中查找<bean>的类型与userService成员属性的类型相比较，类型一致的将其注入，这样就完毕了根据类型自动装配。注意自动装配使用并不多；只有在使用anntation注解时会使用的。byType假如出现相同类型在两个以上，就会出现异常。生命周期lazy-init/default-lazy-init(不重要)bean的何时初始化lazy-init值：default：表达使用<beans>标签中的default-lazy-init值 true:表达context在初始化时，不会初始化这个bean，只有在使用时才会初始化 false：表达context在初始化时，就会初始化这个bean例如：<?xmlversion="1.0"encoding="UTF-8"?><beansxmlns=""xmlns:xsi=""xsi:schemaLocation=""default-lazy-init="false"><beanid="userDao"class="com.wjt276.dao.impl.UserDaoImpl"lazy-init="true"> <propertyname="daoId"value="1"></property></bean><beanid="userDao2"class="com.wjt276.dao.impl.UserDaoImpl"lazy-init="default"> <propertyname="daoId"value="2"></property></bean><beanname="userService"class="com.wjt276.service.UserService"lazy-init="false"></bean></beans>init-methoddestroy-method不要和prototype一起用（了解）init-method：用于<bean>标签中的属性，表达在初始化这个bean之前所需要的执行方法destroy-method:用于<bean>标签中的属性，表达在这个bean销毁时所需要的执行方法。例如关闭连接池。注意：此属性不要与scpoe=”prototype”一起使用，否则会出现其它的问题。例如：<beanid="u"class="com.wjt276.dao.impl.UserDaoImpl"> <propertyname="daoId"value="1"></property></bean><beanname="userService"class="com.wjt276.service.UserService"init-method="init"destroy-method="destroy"> <propertyname="userDao"ref="u"></property></bean>userService类的代码publicclassUserService{ publicvoidinit(){ System.out.println("现在开始初始化UserService"); } privateUserDaouserDao=newUserDaoImpl(); publicUserDaogetUserDao(){returnuserDao; } publicvoidsetUserDao(UserDaouserDao){this.userDao=userDao;} publicvoidadd(Useru){ userDao.save(u);} publicvoiddestroy(){System.out.println("destory"); }}测试代码： publicvoidtestAdd_4()throwsException{ ClassPathXmlApplicationContextfactory=newClassPathXmlApplicationContext("beans.xml"); UserServiceservice=(UserService)factory.getBean("userService"); System.out.println(service.getUserDao()); //由于在非webApplacationContext中不能自动destory，由于需要手动destory //而ApplicationContext没有实现destory方法，因此需要具体的实现类来destory factory.destroy(); }第六课：annotation方式Spring开始使用annotation配置Spring一方面需要在spring的xml配置文献中加入下列红色加粗部分的代码。<?xmlversion="1.0"encoding="UTF-8"?><beansxmlns=""xmlns:xsi=""xmlns:context=""xsi:schemaLocation=""> <context:annotation-config/></beans>这样当spring加载配置文献时，发现有<context:annotation-config/>标签后，会帮我加载以下四个类（用于解决annotation方式的配置）： 1、AutowiredAnnotationBeanPostProcessor, 2、CommonAnnotationBeanPostProcessor,3、PersistenceAnnotationBeanPostProcessor, 4、RequiredAnnotationBeanPostProcessor@Autowired、@Qualifier还是需要在xml文献中配置bean@Autowired位置：可以放在成员属性前面，也可以放在getter或setter方法前面，但是建议放在setter方法前面作用：表达该相应的成员属性可以完毕自动配置功能(默认是根据byType的)例如：xmp配置文献：前缀部分见上面代码，以此略。。。<beanid="u"class="com.wjt276.dao.impl.UserDaoImpl"></bean><beanname="userService"class="com.wjt276.service.UserService"></bean>userServicepublicclassUserService{ privateUserDaouserDao=newUserDaoImpl(); publicUserDaogetUserDao(){returnuserDao;} //表达该成员属性可以自动装配(默认根据类型byType)//annotation建议放在setter方法前面 @Autowired publicvoidsetUserDao(UserDaouserDao){ this.userDao=userDao; } publicvoidadd(Useru){ userDao.save(u); }}说明：这样spring就可以帮我们完毕自动装配功能(默认是根据byType)@Qualifier由于@Autowired默认是根据byType来自动装配注入的。当有多个相同类型的bean时，Spring就会出现异常，提醒找到多个符合条件的bean，但是不知道选择哪个bean来注入。这时我们需要此外一注解来告诉Spring用那个bean，这就是@Qualifier注解,@Qualifier使用value参数来指定注入那个bean代码：publicclassUserService{ privateUserDaouserDao=newUserDaoImpl(); publicUserDaogetUserDao(){returnuserDao; } //表达该成员属性可以自动装配(默认根据类型byType) //当配置文献中有多个相同类型的bean时，需要使用@Qualifier注解来说明那个bean来自动装配 @Autowired publicvoidsetUserDao(@Qualifier(value="u")UserDaouserDao){ this.userDao=userDao; } publicvoidadd(Useru){ userDao.save(u);} }@Resource(重要、推荐)还是需要在xml文献中配置beanJSR-250JCP:JavaCommunityProcess是由多个厂家出人来构成的J2EE组织，重要是用于定Java的一些新的标准而每一个标签都可以称之为一个JSR而每一个新的JSR都会加一个数字是区别什么JSR，可以到官方网看看具体JSR定了哪些新的标准。@Resource代码：importjavax.annotation.Resource;publicclassUserService{ privateUserDaouserDao=newUserDaoImpl(); publicUserDaogetUserDao(){ returnuserDao; } //在这里引用了一个资源，这个资源的名称和这个setter方法后面的成员属性名称一致(userDao) //注意这个@Resource是J2EE的(importjavax.annotation.Resource) @Resource publicvoidsetUserDao(UserDaouserDao){ this.userDao=userDao; } publicvoidadd(Useru){userDao.save(u);}}说明：在这里引用了一个资源，这个资源的名称和这个setter方法后面的成员属性名称一致(userDao)注意这个@Resource是J2EE的(importjavax.annotation.Resource) @Resource默认是根据byName来的，假如没有找到相同的名称再根据byType，当然也可以指定bean的name如下： @Resource(name="u2") publicvoidsetUserDao(UserDaouserDao){ this.userDao=userDao; }注意：一般使用@Resource而不会使用@Autowired局限性：假如没有源码，就无法使用annotation，只能使用xml@Componet以上使用@Autowired、@Resource注解时，还是需要在xml文献配置bean，这样就达不到完全使用annotation进行注解。因此现在引用@Component在那个bean前进行注解，表达那个类是需要的bean有了@Componet注解，这样就不需要在xml文献中配置bean了。注意：@Componet是Spring的注解(org.springframework.stereotype.Component;)例如：前缀部分见上面代码，以此略。。。 <context:annotation-config/> <context:component-scanbase-package="com.wjt276"/></beans><!—不需要配置bean了-->bean类中需要使用@Componet（或@Service、@Repository、@Controller）注解这个类是bean。代码：importjavax.annotation.Resource;importorg.springframework.stereotype.Component;//@Componet注解默认bean的名称是类名首字母小写//也可以运用value属性指定bean的名称@Component(value="userService")publicclassUserService{ privateUserDaouserDao=newUserDaoImpl(); publicUserDaogetUserDao(){returnuserDao;} //在这里引用了一个资源，这个资源的名称和这个setter方法后面的成员属性名称一致(userDao) //注意这个@Resource是J2EE的(importjavax.annotation.Resource) @Resource publicvoidsetUserDao(UserDaouserDao){this.userDao=userDao;} publicvoidadd(Useru){userDao.save(u);}}注意：@Componet注解，默认bean的名称是类的首字母小写，当然也可以运用value属性指定bean名称（在annotation中属性为value可以不写，直接写值） 一般建议@Componet注解后面都指定名称。说明：当Spring在加载配置文献时，发现有<context:component-scanbase-package="com.wjt276"/>标签，并且后面的base-package属性指定了包名，就会在这个指定的包名下面搜索灰，看哪个类用@Componet进行了注解，假如有Spring就将其初始化到容器中，认为是一个bean@Scope、@PostConstruct、@PreDestroy@Scope相应于xml配置文献的scope属性@PostConstruct相应于xml配置文献中的init-method属性@PreDestroy对于应于xml配置文献中的destroy-method属性例如如下：importjavax.annotation.PostConstruct;importjavax.annotation.PreDestroy;importjavax.annotation.Resource;importorg.springframework.context.annotation.Scope;importorg.springframework.stereotype.Component;@Component(value="userService")@Scope("singleton")publicclassUserService{ @PostConstruct publicvoidinit(){System.out.println("现在开始初始化UserService");} privateUserDaouserDao=newUserDaoImpl(); publicUserDaogetUserDao(){returnuserDao;} @Resource publicvoidsetUserDao(UserDaouserDao){this.userDao=userDao;} publicvoidadd(Useru){ userDao.save(u);} @PreDestroy publicvoiddestroy(){System.out.println("destory"); }注解相应的jar包1、@Autowired org.springframework.beans.factory.annotation.Autowired;2、@Qualifier org.springframework.beans.factory.annotation.Qualifier;3、@Componet org.springframework.stereotype.Component;4、@Resource javax.annotation.Resource;5、@Scope org.springframework.context.annotation.Scope;6、@PostConstruct javax.annotation.PreDestroy;7、@PreDestroy javax.annotation.PreDestroy;第七课：AOP(面向切面编程)AOP概念AOP：AspectOrientedProgramming(面向切面编程) 是对面向对象的思维方式的有国补充运用动态代理实现面向切面编程场景：需要在执行方法之前加入一些日记。。。可以使用以下三种方法继承组合动态代理(我们的实例)UserDao接口publicinterfaceUserDao{ publicvoidsave(Useru); publicvoiddelete(Useru); }UserDaoImpl(UserDao接口的现实)publicclassUserDaoImplimplementsUserDao{ @Override publicvoidsave(Useru){System.out.println("usersave...");} @Override publicvoiddelete(Useru){System.out.println("userdelete...");}}UserService(业务层)publicclassUserService{ privateUserDaouserDao=newUserDaoImpl(); publicUserDaogetUserDao(){returnuserDao;} publicvoidsetUserDao(UserDaouse