Spring学习笔记(一) Spring基础IOC、AOP

1.       注入类型

a)       Spring_0300_IOC_Injection_Type

b)       setter（重要）

c)       构造方法（可以忘记）

d)      接口注入（可以忘记）

 

 

以下是setter 注入

 

[html] view plaincopyprint
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  6.   
  7.     <bean id="u" class="com.demo.dao.impl.UserDAOImpl"/>  
  8.     <bean id="userService" class="com.demo.service.UserService">  
  9.         <property name="userDAO" ref="u"/>  
  10.     </bean>  
  11.   
  12. </beans>  

 

[java] view plaincopyprint?
 
  1. package com.demo.service;  
  2. import org.junit.Test;  
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. import com.demo.model.User;  
  7. // Dependency Injection  依赖注入    依赖容器注入的对象 (灵活)  
  8. // Inverse of Control  控制反转   原来具体的实现控制在自己手里，现在控制在容器手里  
  9. public class UserServiceTest {  
  10.     @Test  
  11.     public void testAdd() throws Exception{  
  12.         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");  
  13.           
  14.         UserService service = (UserService)ctx.getBean("userService");  
  15.         User u = new User();  
  16.         u.setUsername("li");  
  17.         u.setPassword("ww");  
  18.         service.add(u);  
  19.     }  
  20. }  

 

构造方法注入

 

[java] view plaincopyprint?
 
  1. public UserService(UserDAO userDAO) {  
  2.     super();  
  3.     this.userDAO = userDAO;  
  4. }  

 

[html] view plaincopyprint?
 
  1. <constructor-arg>  
  2.         <ref bean="u"/>  
  3. </constructor-arg>  

 

 

1.       id vs. name

a)       Spring_0400_IOC_Id_Name

b)       name可以用特殊字符

<bean name="u" class="com.demo.dao.impl.UserDAOImpl"/>  把 id 改成name 原因是可以加特殊字符 （不重要）

 

 

1.       简单属性的注入(不重要)

a)       Spring_0500_IOC_SimpleProperty

b)       <property name=… value=….>

[html] view plaincopyprint?
 
  1. <bean name="u" class="com.demo.dao.impl.UserDAOImpl">  
  2.     <property name="daoId" value="9"></property>  
  3.     <property name="daoStatus" value="helloworld"></property>  
  4. </bean>  

 

1.       <bean 中的scope属性

a)       Spring_0600_IOC_Bean_Scope

b)       singleton 单例 (默认)

c)       proptotype 每次创建新的对象

 

[java] view plaincopyprint?
 
  1. UserService service = (UserService)ctx.getBean("userService");  
  2. UserService service1 = (UserService)ctx.getBean("userService");  
  3. System.out.println(service == service1);  

 

[html] view plaincopyprint?
 
  1. <bean id="userService" class="com.demo.service.UserService" scope="prototype">  

 

1.       集合注入

a)       Spring_0700_IOC_Collections

b)       很少用，不重要！参考程序

 

[html] view plaincopyprint?
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
  6.   
  7.     <bean name="userDAO" class="com.demo.dao.impl.UserDAOImpl">  
  8.         <property name="sets">  
  9.             <set>  
  10.                 <value>1</value>  
  11.                 <value>2</value>  
  12.             </set>  
  13.         </property>  
  14.           
  15.         <property name="lists">  
  16.             <list>  
  17.                 <value>1</value>  
  18.                 <value>2</value>  
  19.                 <value>3</value>  
  20.             </list>  
  21.         </property>  
  22.           
  23.         <property name="maps">  
  24.             <map>  
  25.                 <entry key="1" value="1"></entry>  
  26.                 <entry key="2" value="2"></entry>  
  27.                 <entry key="3" value="3"></entry>  
  28.                 <entry key="4" value="4"></entry>  
  29.                 <entry key="5" value="5"></entry>  
  30.             </map>  
  31.         </property>  
  32.     </bean>  
  33.       
  34.     <bean id="userService" class="com.demo.service.UserService">  
  35.         <property name="userDAO" ref="userDAO"/>  
  36.     </bean>  
  37.   
  38. </beans>  

 

 

1.       自动装配

a)       Spring_0800_IOC_AutoWire

b)       byName

c)       byType

d)       如果所有的bean都用同一种，可以使用beans的属性：default-autowire

2.       生命周期

[html] view plaincopyprint?
 
  1. <bean id="userDAO1" class="com.demo.dao.impl.UserDAOImpl">  
  2.     <property name="daoId" value="1"></property>  
  3. </bean>  
  4.   
  5. <bean id="userDAO2" class="com.demo.dao.impl.UserDAOImpl">  
  6.     <property name="daoId" value="2"></property>  
  7. </bean>  
  8. <bean id="userService" class="com.demo.service.UserService" scope="prototype" autowire="byName">  
  9.     <property name="userDAO" ref="userDAO1"/>  
  10. </bean>  

 

1.       生命周期

a)       Spring_0900_IOC_Life_Cycle

b)       lazy-init (不重要)

c)       init-method destroy-methd 不要和prototype一起用（了解）

 

 

 

 

1.       Annotation第一步：

a)       修改xml文件，参考文档<context:annotation-config />

2.       @Autowired

a)       默认按类型by type

b)       如果想用byName，使用@Qulifier

c)       写在private field（第三种注入形式）（不建议，破坏封装）

d)       如果写在set上，@qualifier需要写在参数上

3.       @Resource（重要）

a)       加入：j2ee/common-annotations.jar

b)       默认按名称，名称找不到，按类型

c)       可以指定特定名称

d)       推荐使用

e)       不足：如果没有源码，就无法运用annotation，只能使用xml

4.       @Component @Service @Controller @Repository

a)       初始化的名字默认为类名首字母小写

b)       可以指定初始化bean的名字

5.       @Scope

6.       @PostConstruct = init-method; @PreDestroy = destroy-method;

 

Annotation-based configuration

 

context.xml  标签自动提示配置

 

xmlns:context="http://www.springframework.org/schema/context"

 

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-2.5.xsd"

 

[plain] view plaincopyprint?
 
  1. <p>1.       Annotation第一步：</p><p>a)       修改xml文件，参考文档<context:annotation-config /></p><p>1.       @Autowired</p><p>a)       默认按类型by type</p><p>b)       如果想用byName，使用@Qulifier</p><p>c)       写在private field（第三种注入形式）（不建议，破坏封装）</p><p>d)       如果写在set上，@qualifier需要写在参数上</p>  
  2.   
  3. 在UserService 类里面  
  4.   
  5. @Autowired  //把和你参数和对应的类型的的bean注入进来 默认的是byName  用的不多，会产生各种问题  
  6.     public void setUserDAO(UserDAO userDAO) {  
  7.         this.userDAO = userDAO;  
  8.     }  
  9.   
  10. (@Qualifier("u")  // 可以指定 匹配那个名字的Bean 注入到参数里面来  
  11.   
  12. public void setUserDAO(@Qualifier("u")UserDAO userDAO) {  
  13.         this.userDAO = userDAO;  
  14.     }  

 

 

1.       @Resource（重要）

a)       加入：j2ee/common-annotations.jar

b)       默认按名称，名称找不到，按类型

c)       可以指定特定名称

d)       推荐使用

e)       不足：如果没有源码，就无法运用annotation，只能使用xml

 

@Resource  //D:\javasoft\ssh\spring-framework-2.5.6\lib\j2ee\common-annotations.jar 包

 

 

1.       @Component @Service @Controller @Repository

a)       初始化的名字默认为类名首字母小写

b)       可以指定初始化bean的名字

2.       @Scope

3.       @PostConstruct = init-method; @PreDestroy = destroy-method;

 

[html] view plaincopyprint?
 
  1. <context:component-scan base-package="com.demo"></context:component-scan>  
[java] view plaincopyprint?
 
  1. package com.demo.dao.impl;  
  2.   
  3. import org.springframework.stereotype.Component;  
  4.   
  5. import com.demo.dao.UserDAO;  
  6. import com.demo.model.User;  
  7.   
  8. @Component("u")  
  9. public class UserDAOImpl implements UserDAO {  
  10.   
  11.     @Override  
  12.     public void save(User u) {  
  13.         System.out.println("user save");  
  14.     }  
  15.   
  16. }  

 

[java] view plaincopyprint?
 
  1. package com.demo.service;  
  2.   
  3. import javax.annotation.Resource;  
  4.   
  5. import org.springframework.beans.factory.annotation.Autowired;  
  6. import org.springframework.beans.factory.annotation.Qualifier;  
  7. import org.springframework.stereotype.Component;  
  8.   
  9. import com.demo.dao.UserDAO;  
  10. import com.demo.dao.impl.UserDAOImpl;  
  11. import com.demo.model.User;  
  12. // 面向接口或者抽象编程,需要用谁直接在service 里面new谁 实现DAO接口即可  
  13. //面向抽象编程就是 灵活  
  14.   
  15. @Component("userService")  
  16. public class UserService {  
  17.     private UserDAO userDAO;  
  18.       
  19.     public void init() {  
  20.         System.out.println("init");  
  21.     }  
  22.       
  23.     public UserDAO getUserDAO() {  
  24.         return userDAO;  
  25.     }  
  26.       
  27.     @Resource(name="u") //常用  
  28.     public void setUserDAO(UserDAO userDAO) {  
  29.         this.userDAO = userDAO;  
  30.     }  
  31.     public void add(User u) {  
  32.         this.userDAO.save(u);  
  33.     }  
  34.       
  35.     public void destroy() {  
  36.         System.out.println("destroy");  
  37.     }  
  38. }  



Spring_1300_Annotation_Pre_Post_Scope

[java] view plaincopyprint?
 
    1. package com.demo.service;  
    2.   
    3. import javax.annotation.PostConstruct;  
    4. import javax.annotation.PreDestroy;  
    5. import javax.annotation.Resource;  
    6.   
    7. import org.springframework.beans.factory.annotation.Autowired;  
    8. import org.springframework.beans.factory.annotation.Qualifier;  
    9. import org.springframework.stereotype.Component;  
    10.   
    11. import com.demo.dao.UserDAO;  
    12. import com.demo.dao.impl.UserDAOImpl;  
    13. import com.demo.model.User;  
    14. // 面向接口或者抽象编程,需要用谁直接在service 里面new谁 实现DAO接口即可  
    15. //面向抽象编程就是 灵活  
    16.   
    17. @Component("userService")  
    18. public class UserService {  
    19.     private UserDAO userDAO;  
    20.       
    21.     @PostConstruct  //构造完成之后  
    22.     public void init() {  
    23.         System.out.println("init");  
    24.     }  
    25.       
    26.     public UserDAO getUserDAO() {  
    27.         return userDAO;  
    28.     }  
    29.       
    30.     @Resource(name="u") //常用  
    31.     public void setUserDAO(UserDAO userDAO) {  
    32.         this.userDAO = userDAO;  
    33.     }  
    34.     public void add(User u) {  
    35.         this.userDAO.save(u);  
    36.     }  
    37.       
    38.     @PreDestroy // 对象销毁之前指定这个方法  
    39.     public void destroy() {  
    40.         System.out.println("destroy");  
    41.     }  
    42. }  
posted @ 2013-12-24 19:33  塞北鸿雁飞  阅读(319)  评论(0)  编辑  收藏  举报