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

1.       注入类型

a)       Spring_0300_IOC_Injection_Type

b)       setter（重要）

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

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

 

 

以下是setter 注入

 

[html]  view plain copy print

 

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 plain copy print ?

 

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 plain copy print ?

 

1. public UserService(UserDAO userDAO) {  
2.     super();  
3.     this.userDAO = userDAO;  
4. }  

 

[html]  view plain copy print ?

 

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 plain copy print ?

 

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 plain copy print ?

 

1. UserService service = (UserService)ctx.getBean("userService");  
2. UserService service1 = (UserService)ctx.getBean("userService");  
3. System.out.println(service == service1);  

 

[html]  view plain copy print ?

 

1. <bean id="userService" class="com.demo.service.UserService" scope="prototype">  

 

1.       集合注入

a)       Spring_0700_IOC_Collections

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

 

[html]  view plain copy print ?

 

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 plain copy print ?

 

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 plain copy print ?

 

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 plain copy print ?

 

1. <context:component-scan base-package="com.demo"></context:component-scan>  

[java]  view plain copy print ?

 

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 plain copy print ?

 

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 plain copy print ?

 

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. }