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

1.       注入类型

a)       Spring_0300_IOC_Injection_Type

b)       setter（重要）

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

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

以下是setter 注入

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. <bean id="u" class="com.demo.dao.impl.UserDAOImpl"/>
7. <bean id="userService" class="com.demo.service.UserService">
8. <property name="userDAO" ref="u"/>
9. </bean>
10. </beans>

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

构造方法注入

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

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=….>

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 每次创建新的对象

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

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

1.       集合注入

a)       Spring_0700_IOC_Collections

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

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. <bean name="userDAO" class="com.demo.dao.impl.UserDAOImpl">
7. <property name="sets">
8. <set>
9. <value>1</value>
10. <value>2</value>
11. </set>
12. </property>
13. <property name="lists">
14. <list>
15. <value>1</value>
16. <value>2</value>
17. <value>3</value>
18. </list>
19. </property>
20. <property name="maps">
21. <map>
22. <entry key="1" value="1"></entry>
23. <entry key="2" value="2"></entry>
24. <entry key="3" value="3"></entry>
25. <entry key="4" value="4"></entry>
26. <entry key="5" value="5"></entry>
27. </map>
28. </property>
29. </bean>
30. <bean id="userService" class="com.demo.service.UserService">
31. <property name="userDAO" ref="userDAO"/>
32. </bean>
33. </beans>

1.       自动装配

a)       Spring_0800_IOC_AutoWire

b)       byName

c)       byType

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

2.       生命周期

1. <bean id="userDAO1" class="com.demo.dao.impl.UserDAOImpl">
2. <property name="daoId" value="1"></property>
3. </bean>
4. <bean id="userDAO2" class="com.demo.dao.impl.UserDAOImpl">
5. <property name="daoId" value="2"></property>
6. </bean>
7. <bean id="userService" class="com.demo.service.UserService" scope="prototype" autowire="byName">
8. <property name="userDAO" ref="userDAO1"/>
9. </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"

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. 在UserService 类里面
3. @Autowired  //把和你参数和对应的类型的的bean注入进来 默认的是byName  用的不多，会产生各种问题
4. public void setUserDAO(UserDAO userDAO) {
5. this.userDAO = userDAO;
6. }
7. (@Qualifier("u")  // 可以指定 匹配那个名字的Bean 注入到参数里面来
8. public void setUserDAO(@Qualifier("u")UserDAO userDAO) {
9. this.userDAO = userDAO;
10. }

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;

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

1. package com.demo.dao.impl;
2. import org.springframework.stereotype.Component;
3. import com.demo.dao.UserDAO;
4. import com.demo.model.User;
5. @Component("u")
6. public class UserDAOImpl implements UserDAO {
7. @Override
8. public void save(User u) {
9. System.out.println("user save");
10. }
11. }

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

Spring_1300_Annotation_Pre_Post_Scope

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