spring

课程内容

1.       面向接口（抽象）编程的概念与好处

2.       IOC/DI的概念与好处

a)       inversion of control

b)       dependency injection

3.       AOP的概念与好处

4.       Spring简介

5.       Spring应用IOC/DI（重要）

a)       xml

b)       annotation

6.       Spring应用AOP（重要）

a)       xml

b)       annotation

7.       Struts2.1.6 +Spring2.5.6 + Hibernate3.3.2整合（重要）

a)       opensessionInviewfilter（记住，解决什么问题，怎么解决）

8.       Spring JDBC

面向接口编程（面向抽象编程）

1.       场景：用户添加

2.       Spring_0100_AbstractOrientedProgramming

a)       不是AOP:Aspect Oriented Programming

3.       好处：灵活

什么是IOC（DI），有什么好处

1.       把自己new的东西改为由容器提供

a)       初始化具体值

b)       装配

2.       好处：灵活装配

Spring简介

1.       项目名称：Spring_0200_IOC_Introduction

2.       环境搭建

a)       只用IOC

                       i.             spring.jar , jarkata-commons/commons-loggin.jar

3.       IOC容器

a)       实例化具体bean

b)       动态装配

4.       AOP支持

a)       安全检查

b)       管理transaction

Spring IOC配置与应用

1.       FAQ:不给提示：

a)       window – preferences – myeclipse – xml – xml catalog

b)       User Specified Entries – add

                        i.             Location:       D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\spring-beans-2.5.xsd

                      ii.             URI:             file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resources/spring-beans-2.5.xsd

                     iii.             KeyType:      Schema Location

                    iv.             Key:              http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

2.       注入类型

a)       Spring_0300_IOC_Injection_Type

b)       setter（重要）

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

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

3.       id vs. name

a)       Spring_0400_IOC_Id_Name

b)       name可以用特殊字符

4.       简单属性的注入

a)       Spring_0500_IOC_SimpleProperty

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

5.       <bean 中的scope属性

a)       Spring_0600_IOC_Bean_Scope

b)       singleton 单例

c)       proptotype 每次创建新的对象

6.       集合注入

a)       Spring_0700_IOC_Collections

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

7.       自动装配

a)       Spring_0800_IOC_AutoWire

b)       byName

c)       byType

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

8.       生命周期

a)       Spring_0900_IOC_Life_Cycle

b)       lazy-init (不重要)

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

9.       Annotation第一步：

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

10.   @Autowired

a)       默认按类型by type

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

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

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

11.   @Resource（重要）

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

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

c)       可以指定特定名称

d)       推荐使用

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

12.   @Component @Service @Controller @Repository

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

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

13.   @Scope

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

 

什么是AOP

1.       面向切面编程Aspect-Oriented-Programming

a)       是对面向对象的思维方式的有力补充

2.       Spring_1400_AOP_Introduction

3.       好处：可以动态的添加和删除在切面上的逻辑而不影响原来的执行代码

a)       Filter

b)       Struts2的interceptor

4.       概念：

a)       JoinPoint

b)       PointCut

c)       Aspect（切面）

d)       Advice

e)       Target

f)        Weave

Spring AOP配置与应用

1.       两种方式：

a)       使用Annotation

b)       使用xml

2.       Annotation

a)       加上对应的xsd文件spring-aop.xsd

b)       beans.xml <aop:aspectj-autoproxy />

c)       此时就可以解析对应的Annotation了

d)       建立我们的拦截类

e)       用@Aspect注解这个类

f)        建立处理方法

g)       用@Before来注解方法

h)       写明白切入点（execution …….）

i)        让spring对我们的拦截器类进行管理@Component

3.       常见的Annotation:

a)       @Pointcut

b)       @Before

c)       @AfterReturning

d)       @AfterThrowing

e)       @After

f)        @Around

4.       织入点语法

a)       void !void

b)       参考文档（* ..）

5.       xml配置AOP

a)       把interceptor对象初始化

b)       <aop:config

                       i.             <aop:aspect …..

1.       <aop:pointcut

2.       <aop:before

Spring整合Hibernate

1.       Spring 指定datasource

a)       参考文档，找dbcp.BasicDataSource

                       i.             c3p0

                     ii.             dbcp

                   iii.             proxool

b)       在DAO或者Service中注入dataSource

c)       在Spring中可以使用PropertyPlaceHolderConfigure来读取Properties文件的内容

2.       Spring整合Hibernate

a)       <bean .. AnnotationSessionFactoryBean>

                       i.             <property dataSource

                     ii.             <annotatedClasses

b)       引入hibernate 系列jar包

c)       User上加Annotation

d)       UserDAO或者UserServie 注入SessionFactory

e)       jar包问题一个一个解决

3.       声明式的事务管理

a)       事务加在DAO层还是Service层？

b)       annotation

                       i.             加入annotation.xsd

                     ii.             加入txManager bean

                   iii.             <tx:annotation-driven

                   iv.             在需要事务的方法上加：@Transactional

                     v.             需要注意，使用SessionFactory.getCurrentSession不要使用OpenSession

c)       @Transactional详解

                       i.             什么时候rollback

1.       运行期异常，非运行期异常不会触发rollback

2.       必须uncheck (没有catch)

3.       不管什么异常，只要你catch了，spring就会放弃管理

4.       事务传播特性：propagation_required

5.       read_only

d)       xml（推荐，可以同时配置好多方法）

                       i.             <bean txmanager

                     ii.             <aop:config

1.       <aop:pointcut

2.       <aop:advisor pointcut-ref advice-ref

                   iii.             <tx:advice: idtransaction-manager =

e)       HibernateTemplate、HibernateCallback、HibernateDaoSupport（不重要）介绍

                       i.             设计模式：TemplateMethod

                     ii.             Callback：回调/钩子函数

                   iii.             第一种：（建议）

1.       在spring中初始化HibernateTemplate，注入sessionFactory

2.       DAO里注入HibernateTemplate

3.       save写getHibernateTemplate.save();

                   iv.             第二种：

1.       从HibernateDaoSupport继承

2.       必须写在xml文件中，无法使用Annotation，因为set方法在父类中，而且是final的

f)        spring整合hibernate的时候使用packagesToScan属性，可以让spring自动扫描对应包下面的实体类

Struts2.1.6 +Spring2.5.6 + Hibernate3.3.2

1.       需要的jar包列表

jar包名称	所在位置	说明
antlr-2.7.6.jar	hibernate/lib/required	解析HQL
aspectjrt	spring/lib/aspectj	AOP
aspectjweaver	..	AOP
cglib-nodep-2.1_3.jar	spring/lib/cglib	代理，二进制增强
common-annotations.jar	spring/lib/j2ee	@Resource
commons-collections-3.1.jar	hibernate/lib/required	集合框架
commons-fileupload-1.2.1.jar	struts/lib	struts
commons-io-1.3.2	struts/lib	struts
commons-logging-1.1.1	单独下载，删除1.0.4(struts/lib)	struts spring
dom4j-1.6.1.jar	hibernate/required	解析xml
ejb3-persistence	hibernate-annotation/lib	@Entity
freemarker-2.3.13	struts/lib	struts
hibernate3.jar	hibernate
hibernate-annotations	hibernate-annotation/
hibernate-common-annotations	hibernate-annotation/lib
javassist-3.9.0.GA.jar	hiberante/lib/required	hibernate
jta-1.1.jar	..	hibernate transaction
junit4.5
mysql-
ognl-2.6.11.jar	struts/lib
slf4j-api-1.5.8.jar	hibernate/lib/required	hibernate-log
slf4j-nop-1.5.8.jar	hibernate/lib/required
spring.jar	spring/dist
struts2-core-2.1.6.jar	struts/lib
xwork-2.1.2.jar	struts/lib	struts2
commons-dbcp	spring/lib/jarkata-commons
commons-pool.jar	..
struts2-spring-plugin-2.1.6.jar	struts/lib

2.       BestPractice：

a)       将这些所有的jar包保存到一个位置，使用的时候直接copy

3.       步骤

a)       加入jar包

b)       首先整合Spring + Hibernate

                       i.             建立对应的package

1.       dao / dao.impl / model / service / service.impl/ test

                     ii.             建立对应的接口与类框架

1.       S2SH_01

                   iii.             建立spring的配置文件（建议自己保留一份经常使用的配置文件，以后用到的时候直接copy改）

                   iv.             建立数据库

                     v.             加入Hibernate注解

1.       在实体类上加相应注解@Entity @Id等

2.       在beans配置文件配置对应的实体类，使之受管

                   vi.             写dao service的实现

                 vii.             加入Spring注解

1.       在对应Service及DAO实现中加入@Component，让spring对其初始化

2.       在Service上加入@Transactional或者使用xml方式（此处建议后者，因为更简单）

3.       在DAO中注入sessionFactory

4.       在Service中注入DAO

5.       写DAO与Service的实现

               viii.             写测试

c)       整合Struts2

                       i.             结合点：Struts2的Action由Spring产生

                     ii.             步骤：

1.       修改web.xml加入 struts的filter

2.       再加入spring的listener，这样的话，webapp一旦启动，spring容器就初始化了

3.       规划struts的action和jsp展现

4.       加入struts.xml

a)      修改配置，由spring替代struts产生Action对象

5.       修改action配置

a)      把类名改为bean对象的名称，这个时候就可以使用首字母小写了

b)      @Scope(“prototype”)不要忘记

                   iii.             struts的读常量：

1.       struts-default.xml

2.       struts-plugin.xml

3.       struts.xml

4.       struts.properties

5.       web.xml

                   iv.             中文问题：

1.       Struts2.1.8已经修正，只需要改i18n.encoding = gbk

2.       使用spring的characterencoding

3.       需要严格注意filter的顺序

4.       需要加到Struts2的filter前面

                     v.             LazyInitializationException

1.       OpenSessionInViewFilter

2.       需要严格顺序问题

3.       需要加到struts2的filter前面

____________________________________________________________________________________________________________________

Spring_0100_AbstractOrientedProgrammingspring

spring 原理模拟

[java] view plain copy print ?

1. package com.demo.model;  
2.   
3. public class User {  
4.     private String username;  
5.     private String password;  
6.     public String getUsername() {  
7.         return username;  
8.     }  
9.     public void setUsername(String username) {  
10.         this.username = username;  
11.     }  
12.     public String getPassword() {  
13.         return password;  
14.     }  
15.     public void setPassword(String password) {  
16.         this.password = password;  
17.     }  
18.       

package com.demo.model;

public class User {
	private String username;
	private String password;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	

[java] view plain copy print ?

1. package com.demo.model;  
2.   
3. public class User {  
4.     private String username;  
5.     private String password;  
6.     public String getUsername() {  
7.         return username;  
8.     }  
9.     public void setUsername(String username) {  
10.         this.username = username;  
11.     }  
12.     public String getPassword() {  
13.         return password;  
14.     }  
15.     public void setPassword(String password) {  
16.         this.password = password;  
17.     }  
18.       

package com.demo.model;

public class User {
	private String username;
	private String password;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	

[java] view plain copy print ?

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

package com.demo.dao.impl;

import com.demo.dao.UserDAO;
import com.demo.model.User;

public class UserDAOImpl implements UserDAO {

	@Override
	public void save(User u) {
		System.out.println("user save");
	}

}

[java] view plain copy print ?

1. package com.demo.service;  
2.   
3. import com.demo.dao.UserDAO;  
4. import com.demo.dao.impl.UserDAOImpl;  
5. import com.demo.model.User;  
6. // 面向接口或者抽象编程,需要用谁直接在service 里面new谁 实现DAO接口即可   
7. //面向抽象编程就是 灵活   
8.   
9. public class UserService {  
10.     private UserDAO userDAO;// = new UserDAOImpl(); 把后半部分放在beans.xml配置文件里   
11.       
12.     public UserDAO getUserDAO() {  
13.         return userDAO;  
14.     }  
15.     public void setUserDAO(UserDAO userDAO) {  
16.         this.userDAO = userDAO;  
17.     }  
18.     public void add(User u) {  
19.         this.userDAO.save(u);  
20.     }  
21. }  

package com.demo.service;

import com.demo.dao.UserDAO;
import com.demo.dao.impl.UserDAOImpl;
import com.demo.model.User;
// 面向接口或者抽象编程,需要用谁直接在service 里面new谁 实现DAO接口即可
//面向抽象编程就是 灵活

public class UserService {
	private UserDAO userDAO;// = new UserDAOImpl(); 把后半部分放在beans.xml配置文件里
	
	public UserDAO getUserDAO() {
		return userDAO;
	}
	public void setUserDAO(UserDAO userDAO) {
		this.userDAO = userDAO;
	}
	public void add(User u) {
		this.userDAO.save(u);
	}
}

[java] view plain copy print ?

1. import java.util.List;  
2.   
3. import org.jdom.Document;  
4. import org.jdom.Element;  
5. import org.jdom.input.SAXBuilder;  
6.   
7.   
8. public class Sample1 {  
9.     public static void main(String[] args) throws Exception {  
10.         SAXBuilder sb = new SAXBuilder();  
11.         Document doc = sb.build(Sample1.class.getClassLoader().getResourceAsStream("test.xml"));    //构造文档对象   
12.         Element root = doc.getRootElement();    // 获取根元素   
13.         List list = root.getChildren("disk");   // 取名字为disk的所有元素   
14.           
15.         for(int i=0; i<list.size(); i++) {  
16.             Element element = (Element)list.get(i);  
17.             String name = element.getAttributeValue("name");  
18.             String capacity = element.getChildText("capacity");  
19.             String directoris = element.getChildText("directories");  
20.             String files = element.getChildText("files");  
21.   
22.             System.out.println("磁盘信息:");  
23.             System.out.println("分区盘符:" + name);  
24.             System.out.println("分区容量：" + capacity);  
25.             System.out.println("目录数: " +directoris);  
26.             System.out.println("文件数： " +files);  
27.             System.out.println("====================================");  
28.         }  
29.     }  
30. }  

import java.util.List;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;


public class Sample1 {
	public static void main(String[] args) throws Exception {
		SAXBuilder sb = new SAXBuilder();
		Document doc = sb.build(Sample1.class.getClassLoader().getResourceAsStream("test.xml"));  	//构造文档对象
		Element root = doc.getRootElement();	// 获取根元素
		List list = root.getChildren("disk");	// 取名字为disk的所有元素
		
		for(int i=0; i<list.size(); i++) {
			Element element = (Element)list.get(i);
			String name = element.getAttributeValue("name");
			String capacity = element.getChildText("capacity");
			String directoris = element.getChildText("directories");
			String files = element.getChildText("files");

			System.out.println("磁盘信息:");
			System.out.println("分区盘符:" + name);
			System.out.println("分区容量：" + capacity);
			System.out.println("目录数: " +directoris);
			System.out.println("文件数： " +files);
			System.out.println("====================================");
		}
	}
}

[java] view plain copy print ?

1. package com.demo.spring;  
2.   
3. public interface BeanFactory {  
4.     public Object getBean(String name);  
5. }  

package com.demo.spring;

public interface BeanFactory {
	public Object getBean(String name);
}

[java] view plain copy print ?

1. package com.demo.spring;  
2.   
3. import java.lang.reflect.Method;  
4. import java.util.HashMap;  
5. import java.util.List;  
6. import java.util.Map;  
7.   
8. import org.jdom.Document;  
9. import org.jdom.Element;  
10. import org.jdom.input.SAXBuilder;  
11.   
12. public class ClassPathXmlApplicationContext implements BeanFactory {  
13.     private Map<String,Object> beans = new HashMap<String, Object>();  
14.       
15.     //IOC Inverse of Control DI Dependency Injection   
16.     public ClassPathXmlApplicationContext() throws Exception {  
17.         SAXBuilder sb = new SAXBuilder();  
18.           
19.         Document doc = sb.build(this.getClass().getClassLoader().getResourceAsStream("beans.xml")); //构造文档   
20.         Element root = doc.getRootElement();    // 获取根元素   
21.         List list = root.getChildren("bean");       //取名字为disk 的所有元素   
22.         for (int i = 0; i < list.size(); i++) {    
23.             Element element = (Element)list.get(i);  
24.             String id=element.getAttributeValue("id");  
25.             String clazz=element.getAttributeValue("class");  
26.             Object o = Class.forName(clazz).newInstance();  
27.             System.out.println(id);  
28.             System.out.println(clazz);  
29.             beans.put(id, o);  
30.               
31.             for(Element propertyElement : (List<Element>)element.getChildren("property")) {  
32.                 String name = propertyElement.getAttributeValue("name");  //userDAO   
33.                 String bean = propertyElement.getAttributeValue("bean");    //u   
34.                 Object beanObject = beans.get(bean);  //UserDAOImpl instance   
35.                   
36.                 String methodName = "set" + name.substring(0,1).toUpperCase() + name.substring(1);  
37.                 System.out.println("method name = " + methodName);  
38.                   
39.                 Method m = o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);  
40.                 m.invoke(o, beanObject);  
41.                   
42.             }  
43.         }  
44.     }  
45.       
46.     @Override  
47.     public Object getBean(String name) {  
48.         return beans.get(name);  
49.     }  
50. }  

package com.demo.spring;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;

public class ClassPathXmlApplicationContext implements BeanFactory {
	private Map<String,Object> beans = new HashMap<String, Object>();
	
	//IOC Inverse of Control DI Dependency Injection
	public ClassPathXmlApplicationContext() throws Exception {
		SAXBuilder sb = new SAXBuilder();
		
		Document doc = sb.build(this.getClass().getClassLoader().getResourceAsStream("beans.xml")); //构造文档
		Element root = doc.getRootElement();    // 获取根元素
		List list = root.getChildren("bean");     	//取名字为disk 的所有元素
		for (int i = 0; i < list.size(); i++) {  
			Element element = (Element)list.get(i);
			String id=element.getAttributeValue("id");
		    String clazz=element.getAttributeValue("class");
		    Object o = Class.forName(clazz).newInstance();
		    System.out.println(id);
		    System.out.println(clazz);
		    beans.put(id, o);
		    
		    for(Element propertyElement : (List<Element>)element.getChildren("property")) {
		    	String name = propertyElement.getAttributeValue("name");  //userDAO
		    	String bean = propertyElement.getAttributeValue("bean");	//u
		    	Object beanObject = beans.get(bean);  //UserDAOImpl instance
		    	
		    	String methodName = "set" + name.substring(0,1).toUpperCase() + name.substring(1);
		    	System.out.println("method name = " + methodName);
		    	
		    	Method m = o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);
		    	m.invoke(o, beanObject);
		    	
		    }
		}
	}
	
	@Override
	public Object getBean(String name) {
		return beans.get(name);
	}
}

[html] view plain copy print ?

1. <beans>  
2.     <bean id="u" class="com.demo.dao.impl.UserDAOImpl"/>  
3.     <bean id="userService" class="com.demo.service.UserService">  
4.         <property name="userDAO" bean="u"/>  
5.     </bean>  
6. </beans>  

<beans>
	<bean id="u" class="com.demo.dao.impl.UserDAOImpl"/>
	<bean id="userService" class="com.demo.service.UserService">
		<property name="userDAO" bean="u"/>
	</bean>
</beans>

[html] view plain copy print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <HD>  
3.     <disk name="C">  
4.         <capacity>8G</capacity>  
5.         <directories>200</directories>  
6.         <files>1580</files>  
7.     </disk>  
8.       
9.     <disk name="C">  
10.         <capacity>8G</capacity>  
11.         <directories>500</directories>  
12.         <files>3000</files>  
13.     </disk>         
14. </HD>  

<?xml version="1.0" encoding="UTF-8"?>
<HD>
	<disk name="C">
		<capacity>8G</capacity>
		<directories>200</directories>
		<files>1580</files>
	</disk>
	
	<disk name="C">
		<capacity>8G</capacity>
		<directories>500</directories>
		<files>3000</files>
	</disk>		
</HD>

spring api 引入方法

在spring jar包上面点右键 ---> properties ---> javadoc Location  -----> file:/D:/javasoft/ssh/spring-framework-2.5.6/docs/api/

在spring里面写配置文件的时候不给提示的解决方法

a)       window – preferences – myeclipse – xml – xml catalog

1.       FAQ:不给提示：

a)       window – preferences – myeclipse – xml – xml catalog

b)       User Specified Entries – add

                        i.             Location:       D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\spring-beans-2.5.xsd

                      ii.             URI:             file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resources/spring-beans-2.5.xsd

                     iii.             KeyType:      Schema Location

                    iv.             Key:              http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

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>  

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://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">

	<bean id="u" class="com.demo.dao.impl.UserDAOImpl"/>
	<bean id="userService" class="com.demo.service.UserService">
		<property name="userDAO" ref="u"/>
	</bean>

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

package com.demo.service;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.demo.model.User;
// Dependency Injection  依赖注入    依赖容器注入的对象 (灵活)
// Inverse of Control  控制反转   原来具体的实现控制在自己手里，现在控制在容器手里
public class UserServiceTest {
	@Test
	public void testAdd() throws Exception{
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
		
		UserService service = (UserService)ctx.getBean("userService");
		User u = new User();
		u.setUsername("li");
		u.setPassword("ww");
		service.add(u);
	}
}

构造方法注入

[java] view plain copy print ?

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

	
	public UserService(UserDAO userDAO) {
		super();
		this.userDAO = userDAO;
	}

[html] view plain copy print ?

1. <constructor-arg>  
2.         <ref bean="u"/>  
3. </constructor-arg>  

<constructor-arg>
		<ref bean="u"/>
</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>  

	<bean name="u" class="com.demo.dao.impl.UserDAOImpl">
		<property name="daoId" value="9"></property>
		<property name="daoStatus" value="helloworld"></property>
	</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);  

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

[html] view plain copy print ?

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

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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://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">

	<bean name="userDAO" class="com.demo.dao.impl.UserDAOImpl">
		<property name="sets">
			<set>
				<value>1</value>
				<value>2</value>
			</set>
		</property>
		
		<property name="lists">
			<list>
				<value>1</value>
				<value>2</value>
				<value>3</value>
			</list>
		</property>
		
		<property name="maps">
			<map>
				<entry key="1" value="1"></entry>
				<entry key="2" value="2"></entry>
				<entry key="3" value="3"></entry>
				<entry key="4" value="4"></entry>
				<entry key="5" value="5"></entry>
			</map>
		</property>
	</bean>
	
	<bean id="userService" class="com.demo.service.UserService">
		<property name="userDAO" ref="userDAO"/>
	</bean>

</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>  

	<bean id="userDAO1" class="com.demo.dao.impl.UserDAOImpl">
		<property name="daoId" value="1"></property>
	</bean>
	
	<bean id="userDAO2" class="com.demo.dao.impl.UserDAOImpl">
		<property name="daoId" value="2"></property>
	</bean>
	<bean id="userService" class="com.demo.service.UserService" scope="prototype" autowire="byName">
		<property name="userDAO" ref="userDAO1"/>
	</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.       Annotation第一步：
a)       修改xml文件，参考文档<context:annotation-config />
1.       @Autowired
a)       默认按类型by type
b)       如果想用byName，使用@Qulifier
c)       写在private field（第三种注入形式）（不建议，破坏封装）
d)       如果写在set上，@qualifier需要写在参数上

在UserService 类里面

@Autowired  //把和你参数和对应的类型的的bean注入进来 默认的是byName  用的不多，会产生各种问题
    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

(@Qualifier("u")  // 可以指定 匹配那个名字的Bean 注入到参数里面来

public void setUserDAO(@Qualifier("u")UserDAO userDAO) {
        this.userDAO = userDAO;
    }

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>  

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

package com.demo.dao.impl;

import org.springframework.stereotype.Component;

import com.demo.dao.UserDAO;
import com.demo.model.User;

@Component("u")
public class UserDAOImpl implements UserDAO {

	@Override
	public void save(User u) {
		System.out.println("user save");
	}

}

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

package com.demo.service;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import com.demo.dao.UserDAO;
import com.demo.dao.impl.UserDAOImpl;
import com.demo.model.User;
// 面向接口或者抽象编程,需要用谁直接在service 里面new谁 实现DAO接口即可
//面向抽象编程就是 灵活

@Component("userService")
public class UserService {
	private UserDAO userDAO;
	
	public void init() {
		System.out.println("init");
	}
	
	public UserDAO getUserDAO() {
		return userDAO;
	}
	
	@Resource(name="u") //常用
	public void setUserDAO(UserDAO userDAO) {
		this.userDAO = userDAO;
	}
	public void add(User u) {
		this.userDAO.save(u);
	}
	
	public void destroy() {
		System.out.println("destroy");
	}
}

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

[+]

1. 什么是AOP
2. Spring AOP配置与应用

什么是AOP

1.       面向切面编程Aspect-Oriented-Programming

a)       是对面向对象的思维方式的有力补充

2.       Spring_1400_AOP_Introduction

3.       好处：可以动态的添加和删除在切面上的逻辑而不影响原来的执行代码

a)       Filter

b)       Struts2的interceptor

4.       概念：

a)       JoinPoint

b)       PointCut

c)       Aspect（切面）

d)       Advice

e)       Target

f)        Weave

_________________________________

动态代理

[java] view plain copy print ?

1. package com.demo.aop;  
2. import java.lang.reflect.InvocationHandler;  
3. import java.lang.reflect.Method;  
4.   
5. public class LogInterceptor implements InvocationHandler {  
6.     private Object target;  
7.       
8.     public Object getTarget() {  
9.         return target;  
10.     }  
11.     public void setTarget(Object target) {  
12.         this.target = target;  
13.     }  
14.     public void beforeMethod(Method m) {  
15.         System.out.println(m.getName() + " start");  
16.     }  
17.     /*Object proxy：指被代理的对象。  
18.     Method method：要调用的方法  
19.     Object[] args：方法调用时所需要的参数  
20.      */  
21.       
22.     @Override  
23.     public Object invoke(Object proxy, Method m, Object[] args)  
24.             throws Throwable {  
25.         beforeMethod(m);  
26.         m.invoke(target, args);  
27.         return null;  
28.     }  
29. }  

package com.demo.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class LogInterceptor implements InvocationHandler {
	private Object target;
	
	public Object getTarget() {
		return target;
	}
	public void setTarget(Object target) {
		this.target = target;
	}
	public void beforeMethod(Method m) {
		System.out.println(m.getName() + " start");
	}
	/*Object proxy：指被代理的对象。 
	Method method：要调用的方法 
	Object[] args：方法调用时所需要的参数 
	 */
	
	@Override
	public Object invoke(Object proxy, Method m, Object[] args)
			throws Throwable {
		beforeMethod(m);
		m.invoke(target, args);
		return null;
	}
}

[java] view plain copy print ?

1. package com.demo.dao;  
2.   
3. import com.demo.model.User;  
4.   
5. public interface UserDAO {  
6.     public void save(User u);  
7.       
8.     public void delete();  
9. }  

package com.demo.dao;

import com.demo.model.User;

public interface UserDAO {
	public void save(User u);
	
	public void delete();
}

[java] view plain copy print ?

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

package com.demo.dao.impl;
import com.demo.dao.UserDAO;
import com.demo.model.User;

public class UserDAOImpl implements UserDAO {

	@Override
	public void save(User u) {
		System.out.println("user save");
	}
	@Override
	public void delete() {
		System.out.println("user deleted");
	}
}

[java] view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import com.demo.dao.UserDAO;  
4. import com.demo.model.User;  
5.   
6. public class UserDAOImpl2 extends UserDAOImpl {  
7.   
8.     @Override  
9.     public void save(User u) {  
10.         System.out.println("save start ....");  
11.         super.save(u);  
12.     }  
13.   
14. }  

package com.demo.dao.impl;

import com.demo.dao.UserDAO;
import com.demo.model.User;

public class UserDAOImpl2 extends UserDAOImpl {

	@Override
	public void save(User u) {
		System.out.println("save start ....");
		super.save(u);
	}

}

[java] view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import com.demo.aop.LogInterceptor;  
4. import com.demo.dao.UserDAO;  
5. import com.demo.model.User;  
6.   
7. public class UserDAOImpl3 extends UserDAOImpl {  
8.   
9.     private UserDAO userDAO = new UserDAOImpl();  
10.       
11.     @Override  
12.     public void save(User u) {  
13.         new LogInterceptor().beforeMethod(null);  
14.         userDAO.save(u);  
15.     }  
16.     public void delete() {  
17.           
18.     }  
19.   
20. }  

package com.demo.dao.impl;

import com.demo.aop.LogInterceptor;
import com.demo.dao.UserDAO;
import com.demo.model.User;

public class UserDAOImpl3 extends UserDAOImpl {

	private UserDAO userDAO = new UserDAOImpl();
	
	@Override
	public void save(User u) {
		new LogInterceptor().beforeMethod(null);
		userDAO.save(u);
	}
	public void delete() {
		
	}

}

[java] view plain copy print ?

1. package com.demo.service;  
2.   
3. import java.lang.reflect.Proxy;  
4.   
5. import org.junit.Test;  
6.   
7. import com.demo.aop.LogInterceptor;  
8. import com.demo.dao.UserDAO;  
9. import com.demo.dao.impl.UserDAOImpl;  
10. import com.demo.model.User;  
11. import com.demo.spring.BeanFactory;  
12. import com.demo.spring.ClassPathXmlApplicationContext;  
13.   
14. public class UserServiceTest {  
15.       
16.       
17.     @Test  
18.     public void testAdd() throws Exception{  
19.         ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext();  
20.           
21.         UserService service = (UserService)ctx.getBean("userService");  
22.     }  
23.       
24.     @Test  
25.     public void testProxy() {  
26.         UserDAO userDAO = new UserDAOImpl();  
27.         LogInterceptor li = new LogInterceptor();  
28.         li.setTarget(userDAO);  
29.         /*1、第一个参数是说我们要用那个ClassLoader来产生 
30.          * 2、第二个参数是说产生的那些被代理对象它应该是实现那些接口 
31.          * 3、当我产生代理之后调用代理里面的方法，要用那一个handler 进行处理 
32.          * (参数说明：  
33.         ClassLoader loader：类加载器  
34.         Class<?>[] interfaces：得到全部的接口  
35.         InvocationHandler h：得到InvocationHandler接口的子类实例 ) 
36.          * */  
37.           
38.         UserDAO userDAOproxy =  (UserDAO)Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), new Class[]{UserDAO.class}, li);  
39.         userDAOproxy.delete();  
40.         userDAOproxy.save(new User());  
41.     }  
42. }  

package com.demo.service;

import java.lang.reflect.Proxy;

import org.junit.Test;

import com.demo.aop.LogInterceptor;
import com.demo.dao.UserDAO;
import com.demo.dao.impl.UserDAOImpl;
import com.demo.model.User;
import com.demo.spring.BeanFactory;
import com.demo.spring.ClassPathXmlApplicationContext;

public class UserServiceTest {
	
	
	@Test
	public void testAdd() throws Exception{
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext();
		
		UserService service = (UserService)ctx.getBean("userService");
	}
	
	@Test
	public void testProxy() {
		UserDAO userDAO = new UserDAOImpl();
		LogInterceptor li = new LogInterceptor();
		li.setTarget(userDAO);
		/*1、第一个参数是说我们要用那个ClassLoader来产生
		 * 2、第二个参数是说产生的那些被代理对象它应该是实现那些接口
		 * 3、当我产生代理之后调用代理里面的方法，要用那一个handler 进行处理
		 * (参数说明： 
		ClassLoader loader：类加载器 
		Class<?>[] interfaces：得到全部的接口 
		InvocationHandler h：得到InvocationHandler接口的子类实例 )
		 * */
		
		UserDAO userDAOproxy =  (UserDAO)Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), new Class[]{UserDAO.class}, li);
		userDAOproxy.delete();
		userDAOproxy.save(new User());
	}
}

[java] view plain copy print ?

1. aop 标签自动提示配置  
2.   
3. xmlns:aop="http://www.springframework.org/schema/aop"  
4.   
5.  http://www.springframework.org/schema/aop    
6.   
7. http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"  

aop 标签自动提示配置

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

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

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

Spring AOP配置与应用

1.       两种方式：

a)       使用Annotation

b)       使用xml

2.       Annotation

a)       加上对应的xsd文件spring-aop.xsd

b)       beans.xml <aop:aspectj-autoproxy />

c)       此时就可以解析对应的Annotation了

d)       建立我们的拦截类

e)       用@Aspect注解这个类

f)        建立处理方法

g)       用@Before来注解方法

h)       写明白切入点（execution …….）

i)        让spring对我们的拦截器类进行管理@Component

3.       常见的Annotation:

a)       @Pointcut

b)       @Before

c)       @AfterReturning

d)       @AfterThrowing

e)       @After

f)        @Around

4.       织入点语法

a)       void !void

b)       参考文档（* ..）

5.       xml配置AOP

a)       把interceptor对象初始化

b)       <aop:config

                       i.             <aop:aspect …..

1.       <aop:pointcut

2.       <aop:before

<aop:aspectj-autoproxy />  // 自动的帮我产生代理,容器启动过程当中，它扫描到了有这样一个东西，需要产生代理，它就会帮你产生代理

aspectj 专门实现代理的框架

[java] view plain copy print ?

1. package com.demo.aop;  
2.   
3. import org.aspectj.lang.annotation.Aspect;  
4. import org.aspectj.lang.annotation.Before;  
5. import org.springframework.stereotype.Component;  
6.   
7. @Aspect  //切面  可以把它切到其他的方法上面去   
8. @Component  //初始化 LogInterceptor    
9. public class LogInterceptor {  
10.     @Before("execution(public void com.demo.dao.impl.UserDAOImpl.save(com.demo.model.User))") // 在方法执行之前先执行我这个方法   
11.     public void before() {  
12.         System.out.println("method start");  
13.     }  
14. }  

package com.demo.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect  //切面  可以把它切到其他的方法上面去
@Component  //初始化 LogInterceptor 
public class LogInterceptor {
	@Before("execution(public void com.demo.dao.impl.UserDAOImpl.save(com.demo.model.User))") // 在方法执行之前先执行我这个方法
	public void before() {
		System.out.println("method start");
	}
}

[java] view plain copy print ?

1. package com.demo.aop;  
2.   
3. import org.aspectj.lang.annotation.AfterReturning;  
4. import org.aspectj.lang.annotation.Aspect;  
5. import org.aspectj.lang.annotation.Before;  
6. import org.aspectj.lang.annotation.Pointcut;  
7. import org.springframework.stereotype.Component;  
8.   
9. @Aspect  //切面  可以把它切到其他的方法上面去   
10. @Component  //初始化 LogInterceptor    
11. public class LogInterceptor {  
12.     @Pointcut("execution(public * com.demo.dao..*.*(..))")    
13. //  @Pointcut("execution(public * com.demo.service..*.add(..))")   
14.     public void myMethod() {}  
15.   
16.     @Before("myMethod()")  
17.     public void before() {  
18.         System.out.println("method before");  
19.     }  
20.       
21.     @AfterReturning("myMethod()")  
22.     public void afterReturning() {  
23.         System.out.println("method after Returning");  
24.     }  
25.       
26.       
27.       
28.       
29.     /*//@Before("execution(public void com.demo.dao.impl.UserDAOImpl.save(com.demo.model.User))") // 在方法执行之前先执行我这个方法 
30.     @Before("execution(public * com.demo.dao..*.*(..))")  //记住此一个方法即可 
31.     public void before() { 
32.         System.out.println("method before"); 
33.     } 
34.      
35.     @After("execution(public * com.demo.dao..*.*(..))")  //记住此一个方法即可 
36.     public void afterReturning() { 
37.         System.out.println("method after Returning"); 
38.     }*/  
39. }  

package com.demo.aop;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect  //切面  可以把它切到其他的方法上面去
@Component  //初始化 LogInterceptor 
public class LogInterceptor {
	@Pointcut("execution(public * com.demo.dao..*.*(..))")  
//	@Pointcut("execution(public * com.demo.service..*.add(..))")
	public void myMethod() {}

	@Before("myMethod()")
	public void before() {
		System.out.println("method before");
	}
	
	@AfterReturning("myMethod()")
	public void afterReturning() {
		System.out.println("method after Returning");
	}
	
	
	
	
	/*//@Before("execution(public void com.demo.dao.impl.UserDAOImpl.save(com.demo.model.User))") // 在方法执行之前先执行我这个方法
	@Before("execution(public * com.demo.dao..*.*(..))")  //记住此一个方法即可
	public void before() {
		System.out.println("method before");
	}
	
	@After("execution(public * com.demo.dao..*.*(..))")  //记住此一个方法即可
	public void afterReturning() {
		System.out.println("method after Returning");
	}*/
}

        Spring_1600_AOP_XML  （重点）

[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.        xmlns:context="http://www.springframework.org/schema/context"  
5.        xmlns:aop="http://www.springframework.org/schema/aop"  
6.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
7.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
8.            http://www.springframework.org/schema/context  
9.            http://www.springframework.org/schema/context/spring-context-2.5.xsd  
10.            http://www.springframework.org/schema/aop   
11.            http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  
12.   
13.     <context:annotation-config />  
14.     <context:component-scan base-package="com.demo"/>  
15.       
16.     <bean id="logInterceptor" class="com.demo.aop.LogInterceptor"></bean>  
17.       
18.     <!--<aop:config>  
19.         <aop:pointcut expression="execution(public * com.demo.service..*.add(..))"   
20.             id="servicePointcut"/>  
21.               
22.         <aop:aspect id="logAspect" ref="logInterceptor">  
23.             <aop:before method="before" pointcut-ref="servicePointcut" />  
24.         </aop:aspect>  
25.       
26.     </aop:config>  
27.     -->  
28.       
29.     <aop:config>  
30.         <aop:aspect id="logAspect" ref="logInterceptor">  
31.             <aop:before method="before" pointcut="execution(public * com.demo.service..*.add(..))" />  
32.         </aop:aspect>  
33.       
34.     </aop:config>  
35.       
36. </beans>  

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <context:annotation-config />
    <context:component-scan base-package="com.demo"/>
    
    <bean id="logInterceptor" class="com.demo.aop.LogInterceptor"></bean>
    
    <!--<aop:config>
        <aop:pointcut expression="execution(public * com.demo.service..*.add(..))" 
            id="servicePointcut"/>
            
        <aop:aspect id="logAspect" ref="logInterceptor">
            <aop:before method="before" pointcut-ref="servicePointcut" />
        </aop:aspect>
    
    </aop:config>
    -->
    
    <aop:config>
        <aop:aspect id="logAspect" ref="logInterceptor">
            <aop:before method="before" pointcut="execution(public * com.demo.service..*.add(..))" />
        </aop:aspect>
    
    </aop:config>
    
</beans>

    Spring_1600_Spring_DataSource

[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.        xmlns:context="http://www.springframework.org/schema/context"  
5.        xmlns:aop="http://www.springframework.org/schema/aop"  
6.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
7.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
8.            http://www.springframework.org/schema/context  
9.            http://www.springframework.org/schema/context/spring-context-2.5.xsd  
10.            http://www.springframework.org/schema/aop   
11.            http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  
12.   
13.     <context:annotation-config />  
14.     <context:component-scan base-package="com.demo"/>  
15.       
16.     <!--  
17.       <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
18.       <property name="driverClassName" value="com.mysql.jdbc.Driver"/>  
19.       <property name="url" value="jdbc:mysql://localhost:3306/spring"/>  
20.       <property name="username" value="root"/>  
21.       <property name="password" value="root"/>  
22.       </bean>  
23.     -->  
24.   
25.         <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
26.         <property name="locations">  
27.             <value>classpath:jdbc.properties</value>  
28.         </property>  
29.         </bean>  
30.       
31.         <bean id="dataSource" destroy-method="close"  
32.           class="org.apache.commons.dbcp.BasicDataSource">  
33.         <property name="driverClassName" value="${jdbc.driverClassName}"/>  
34.         <property name="url" value="${jdbc.url}"/>  
35.         <property name="username" value="${jdbc.username}"/>  
36.         <property name="password" value="${jdbc.password}"/>  
37.         </bean>  
38.       
39.     <bean id="logInterceptor" class="com.demo.aop.LogInterceptor"></bean>  
40.       
41. </beans>  

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

	<context:annotation-config />
	<context:component-scan base-package="com.demo"/>
	
	<!--
	  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
	  <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
	  <property name="url" value="jdbc:mysql://localhost:3306/spring"/>
	  <property name="username" value="root"/>
	  <property name="password" value="root"/>
	  </bean>
	-->

		<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
	    <property name="locations">
	        <value>classpath:jdbc.properties</value>
	    </property>
		</bean>
	
		<bean id="dataSource" destroy-method="close"
	      class="org.apache.commons.dbcp.BasicDataSource">
	    <property name="driverClassName" value="${jdbc.driverClassName}"/>
	    <property name="url" value="${jdbc.url}"/>
	    <property name="username" value="${jdbc.username}"/>
	    <property name="password" value="${jdbc.password}"/>
		</bean>
	
	<bean id="logInterceptor" class="com.demo.aop.LogInterceptor"></bean>
	
</beans>

[html] view plain copy print ?

1. jdbc.driverClassName=com.mysql.jdbc.Driver  
2. jdbc.url=jdbc:mysql://localhost:3306/spring  
3. jdbc.username=root  
4. jdbc.password=root  

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.username=root
jdbc.password=root

[java] view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import java.sql.Connection;  
4. import java.sql.SQLException;  
5.   
6. import javax.annotation.Resource;  
7. import javax.sql.DataSource;  
8.   
9. import org.springframework.stereotype.Component;  
10.   
11. import com.demo.dao.UserDAO;  
12. import com.demo.model.User;  
13.   
14. @Component("u")  
15. public class UserDAOImpl implements UserDAO {  
16.     private DataSource dataSource;  
17.     public DataSource getDataSource() {  
18.         return dataSource;  
19.     }  
20.     @Resource  
21.     public void setDataSource(DataSource dataSource) {  
22.         this.dataSource = dataSource;  
23.     }  
24.   
25.     @Override  
26.     public void save(User u) {  
27.         Connection conn = null;  
28.         try {  
29.             conn = dataSource.getConnection();  
30.             conn.createStatement().executeUpdate("insert into user values (null,'lisi')");  
31.         } catch (SQLException e) {  
32.             e.printStackTrace();  
33.         } finally {  
34.             try {  
35.                 if(conn != null) {  
36.                     conn.close();  
37.                     conn = null;  
38.                 }  
39.             } catch (SQLException e2) {  
40.                 e2.printStackTrace();  
41.             }  
42.         }  
43.           
44.         System.out.println("user save");  
45.     }  
46.   
47. }  

package com.demo.dao.impl;

import java.sql.Connection;
import java.sql.SQLException;

import javax.annotation.Resource;
import javax.sql.DataSource;

import org.springframework.stereotype.Component;

import com.demo.dao.UserDAO;
import com.demo.model.User;

@Component("u")
public class UserDAOImpl implements UserDAO {
	private DataSource dataSource;
	public DataSource getDataSource() {
		return dataSource;
	}
	@Resource
	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}

	@Override
	public void save(User u) {
		Connection conn = null;
		try {
			conn = dataSource.getConnection();
			conn.createStatement().executeUpdate("insert into user values (null,'lisi')");
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			try {
				if(conn != null) {
					conn.close();
					conn = null;
				}
			} catch (SQLException e2) {
				e2.printStackTrace();
			}
		}
		
		System.out.println("user save");
	}

}

——————————————————————————————————————————————————————————————————————————

[plain] view plain copy print ?

1. Spring整合Hibernate  
2. 1.  Spring 指定datasource  
3. a)  参考文档，找dbcp.BasicDataSource  
4. i.  c3p0  
5. ii. dbcp  
6. iii.    proxool  
7. b)  在DAO或者Service中注入dataSource  
8. c)  在Spring中可以使用PropertyPlaceHolderConfigure来读取Properties文件的内容  
9. 2.  Spring整合Hibernate  
10. a)  <bean .. AnnotationSessionFactoryBean>  
11. i.  <property dataSource  
12. ii. <annotatedClasses  
13. b)  引入hibernate 系列jar包  
14. c)  User上加Annotation  
15. d)  UserDAO或者UserServie 注入SessionFactory  
16. e)  jar包问题一个一个解决  
17. 3.  声明式的事务管理  
18. a)  事务加在DAO层还是Service层？  
19. b)  annotation  
20. i.  加入annotation.xsd  
21. ii. 加入txManager bean  
22. iii.    <tx:annotation-driven  
23. iv. 在需要事务的方法上加：@Transactional  
24. v.  需要注意，使用SessionFactory.getCurrentSession 不要使用OpenSession  
25. c)  @Transactional详解  
26. i.  什么时候rollback   
27. 1.  运行期异常，非运行期异常不会触发rollback  
28. 2.  必须uncheck (没有catch)  
29. 3.  不管什么异常，只要你catch了，spring就会放弃管理  
30. 4.  事务传播特性：propagation_required  
31. 5.  read_only  
32. d)  xml（推荐，可以同时配置好多方法）  
33. i.  <bean txmanager  
34. ii. <aop:config   
35. 1.  <aop:pointcut  
36. 2.  <aop:advisor pointcut-ref advice-ref  
37. iii.    <tx:advice: id transaction-manager =   
38. e)  HibernateTemplate、HibernateCallback、HibernateDaoSupport（不重要）介绍  
39. i.  设计模式：Template Method  
40. ii. Callback：回调/钩子函数  
41. iii.    第一种：（建议）  
42. 1.  在spring中初始化HibernateTemplate，注入sessionFactory  
43. 2.  DAO里注入HibernateTemplate  
44. 3.  save写getHibernateTemplate.save();  
45. iv. 第二种：  
46. 1.  从HibernateDaoSupport继承  
47. 2.  必须写在xml文件中，无法使用Annotation，因为set方法在父类中，而且是final的  
48. f)  spring整合hibernate的时候使用packagesToScan属性，可以让spring自动扫描对应包下面的实体类  

Spring整合Hibernate
1.	Spring 指定datasource
a)	参考文档，找dbcp.BasicDataSource
i.	c3p0
ii.	dbcp
iii.	proxool
b)	在DAO或者Service中注入dataSource
c)	在Spring中可以使用PropertyPlaceHolderConfigure来读取Properties文件的内容
2.	Spring整合Hibernate
a)	<bean .. AnnotationSessionFactoryBean>
i.	<property dataSource
ii.	<annotatedClasses
b)	引入hibernate 系列jar包
c)	User上加Annotation
d)	UserDAO或者UserServie 注入SessionFactory
e)	jar包问题一个一个解决
3.	声明式的事务管理
a)	事务加在DAO层还是Service层？
b)	annotation
i.	加入annotation.xsd
ii.	加入txManager bean
iii.	<tx:annotation-driven
iv.	在需要事务的方法上加：@Transactional
v.	需要注意，使用SessionFactory.getCurrentSession 不要使用OpenSession
c)	@Transactional详解
i.	什么时候rollback 
1.	运行期异常，非运行期异常不会触发rollback
2.	必须uncheck (没有catch)
3.	不管什么异常，只要你catch了，spring就会放弃管理
4.	事务传播特性：propagation_required
5.	read_only
d)	xml（推荐，可以同时配置好多方法）
i.	<bean txmanager
ii.	<aop:config 
1.	<aop:pointcut
2.	<aop:advisor pointcut-ref advice-ref
iii.	<tx:advice: id transaction-manager = 
e)	HibernateTemplate、HibernateCallback、HibernateDaoSupport（不重要）介绍
i.	设计模式：Template Method
ii.	Callback：回调/钩子函数
iii.	第一种：（建议）
1.	在spring中初始化HibernateTemplate，注入sessionFactory
2.	DAO里注入HibernateTemplate
3.	save写getHibernateTemplate.save();
iv.	第二种：
1.	从HibernateDaoSupport继承
2.	必须写在xml文件中，无法使用Annotation，因为set方法在父类中，而且是final的
f)	spring整合hibernate的时候使用packagesToScan属性，可以让spring自动扫描对应包下面的实体类

1.       Spring 指定datasource

a)       参考文档，找dbcp.BasicDataSource

                       i.             c3p0

                     ii.             dbcp

                   iii.             proxool

b)       在DAO或者Service中注入dataSource

c)       在Spring中可以使用PropertyPlaceHolderConfigure来读取Properties文件的内容

beans.xml 几种dataSource连接方式

[html] view plain copy print ?

1. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
2.   <property name="driverClassName" value="com.mysql.jdbc.Driver"/>  
3.   <property name="url" value="jdbc:mysql://localhost:3306/spring"/>  
4.   <property name="username" value="root"/>  
5.   <property name="password" value="root"/>  
6.   </bean>  

 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
	  <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
	  <property name="url" value="jdbc:mysql://localhost:3306/spring"/>
	  <property name="username" value="root"/>
	  <property name="password" value="root"/>
	  </bean>

[html] view plain copy print ?

1. <bean id="dataSource" destroy-method="close"  
2.           class="org.apache.commons.dbcp.BasicDataSource">  
3.         <property name="driverClassName" value="${jdbc.driverClassName}"/>  
4.         <property name="url" value="${jdbc.url}"/>  
5.         <property name="username" value="${jdbc.username}"/>  
6.         <property name="password" value="${jdbc.password}"/>  
7.         </bean>  

<bean id="dataSource" destroy-method="close"
	      class="org.apache.commons.dbcp.BasicDataSource">
	    <property name="driverClassName" value="${jdbc.driverClassName}"/>
	    <property name="url" value="${jdbc.url}"/>
	    <property name="username" value="${jdbc.username}"/>
	    <property name="password" value="${jdbc.password}"/>
		</bean>

[html] view plain copy print ?

1. <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
2.    <property name="locations">  
3.        <value>classpath:jdbc.properties</value>  
4.    </property>  
5. </bean>  
6.   
7. <bean id="dataSource" destroy-method="close"  
8.      class="org.apache.commons.dbcp.BasicDataSource">  
9.    <property name="driverClassName" value="${jdbc.driverClassName}"/>  
10.    <property name="url" value="${jdbc.url}"/>  
11.    <property name="username" value="${jdbc.username}"/>  
12.    <property name="password" value="${jdbc.password}"/>  
13. </bean>  

		<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
	    <property name="locations">
	        <value>classpath:jdbc.properties</value>
	    </property>
		</bean>
	
		<bean id="dataSource" destroy-method="close"
	      class="org.apache.commons.dbcp.BasicDataSource">
	    <property name="driverClassName" value="${jdbc.driverClassName}"/>
	    <property name="url" value="${jdbc.url}"/>
	    <property name="username" value="${jdbc.username}"/>
	    <property name="password" value="${jdbc.password}"/>
		</bean>

1.       Spring整合Hibernate

a)       <bean .. AnnotationSessionFactoryBean>

                       i.             <property dataSource

                     ii.             <annotatedClasses

b)       引入hibernate 系列jar包

c)       User上加Annotation

d)       UserDAO或者UserServie 注入SessionFactory

e)       jar包问题一个一个解决

下面用hibernate 的sessionFactory连接数据库

[html] view plain copy print ?

1. <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
2.     <property name="dataSource" ref="dataSource"/>  
3.     <property name="annotatedClasses">  
4.       <list>  
5.         <value>com.demo.model.User</value>  
6.       </list>  
7.     </property>  
8.     <property name="hibernateProperties">  
9.     <props>  
10.         <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
11.             <prop key="hibernate.show_sql">true</prop>  
12.         </props>  
13.     </property>  
14.   </bean>  

 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
	    <property name="dataSource" ref="dataSource"/>
	    <property name="annotatedClasses">
	      <list>
	        <value>com.demo.model.User</value>
	      </list>
	    </property>
	    <property name="hibernateProperties">
	    <props>
	     	<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
          	<prop key="hibernate.show_sql">true</prop>
         </props>
	    </property>
	  </bean>

[java] view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import javax.annotation.Resource;  
4. import org.hibernate.Session;  
5. import org.hibernate.SessionFactory;  
6. import org.springframework.stereotype.Component;  
7. import com.demo.dao.UserDAO;  
8. import com.demo.model.User;  
9.   
10. @Component("u")  
11. public class UserDAOImpl implements UserDAO {  
12.       
13.     private SessionFactory sessionFactory;  
14.     public SessionFactory getSessionFactory() {  
15.         return sessionFactory;  
16.     }  
17.     @Resource  
18.     public void setSessionFactory(SessionFactory sessionFactory) {  
19.         this.sessionFactory = sessionFactory;  
20.     }  
21.       
22.     @Override  
23.     public void save(User u) {  
24.         Session session = sessionFactory.openSession();  
25.         session.beginTransaction();  
26.         session.save(u);  
27.         session.getTransaction().commit();  
28.         session.close();  
29.         System.out.println("user save");  
30.     }  
31.   
32. }  

package com.demo.dao.impl;

import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Component;
import com.demo.dao.UserDAO;
import com.demo.model.User;

@Component("u")
public class UserDAOImpl implements UserDAO {
    
    private SessionFactory sessionFactory;
    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }
    @Resource
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
    
    @Override
    public void save(User u) {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        session.save(u);
        session.getTransaction().commit();
        session.close();
        System.out.println("user save");
    }

}

org.hibernate.HibernateException: No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here    表示这里不能用.getCurrentSession()

[java] view plain copy print ?

1. @Component("logDAO") //就是spring在为这个类生成对象的时候它的key、id、名字是LgDAO  

@Component("logDAO") //就是spring在为这个类生成对象的时候它的key、id、名字是LgDAO

1.       声明式的事务管理

a)       事务加在DAO层还是Service层？

b)       annotation

                       i.             加入annotation.xsd

                     ii.             加入txManager bean

                   iii.             <tx:annotation-driven

                   iv.             在需要事务的方法上加：@Transactional

                     v.             需要注意，使用SessionFactory.getCurrentSession不要使用OpenSession

[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.        xmlns:context="http://www.springframework.org/schema/context"  
5.        xmlns:aop="http://www.springframework.org/schema/aop"  
6.        xmlns:tx="http://www.springframework.org/schema/tx"  
7.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
8.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
9.            http://www.springframework.org/schema/context  
10.            http://www.springframework.org/schema/context/spring-context-2.5.xsd  
11.            http://www.springframework.org/schema/aop   
12.            http://www.springframework.org/schema/aop/spring-aop-2.5.xsd  
13.            http://www.springframework.org/schema/tx   
14.            http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
15.   
16.     <context:annotation-config />  
17.     <context:component-scan base-package="com.demo"/>  
18.   
19.             <!--  
20.       <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
21.       <property name="driverClassName" value="com.mysql.jdbc.Driver"/>  
22.       <property name="url" value="jdbc:mysql://localhost:3306/spring"/>  
23.       <property name="username" value="root"/>  
24.       <property name="password" value="root"/>  
25.       </bean>  
26.     -->  
27.   
28.         <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
29.         <property name="locations">  
30.             <value>classpath:jdbc.properties</value>  
31.         </property>  
32.         </bean>  
33.       
34.         <bean id="dataSource" destroy-method="close"  
35.           class="org.apache.commons.dbcp.BasicDataSource">  
36.         <property name="driverClassName" value="${jdbc.driverClassName}"/>  
37.         <property name="url" value="${jdbc.url}"/>  
38.         <property name="username" value="${jdbc.username}"/>  
39.         <property name="password" value="${jdbc.password}"/>  
40.         </bean>  
41.   
42. <!-- -   <bean id="logInterceptor" class="com.demo.aop.LogInterceptor"></bean> -->  
43.   
44.      <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
45.         <property name="dataSource" ref="dataSource"/>  
46.         <property name="annotatedClasses">  
47.           <list>  
48.             <value>com.demo.model.User</value>  
49.             <value>com.demo.model.Log</value>  
50.           </list>  
51.         </property>  
52.         <property name="hibernateProperties">  
53.         <props>  
54.             <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
55.             <prop key="hibernate.show_sql">true</prop>  
56.          </props>  
57.         </property>  
58.       </bean>  
59.         
60.       <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
61.       <property name="sessionFactory" ref="sessionFactory"/>  
62.       </bean>  
63.       
64.       <tx:annotation-driven transaction-manager="txManager"/>  
65.       
66. </beans>  
67.   
68. /*  
69.     @Transactional //运行时异常会回滚  
70.     public void add(User u) {  
71.         this.userDAO.save(u);  
72.         Log log = new Log();  
73.         log.setMsg("a log saved");  
74.         this.logDAO.save(log);  
75.     }  
76. */  

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx 
           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

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

			<!--
	  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
	  <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
	  <property name="url" value="jdbc:mysql://localhost:3306/spring"/>
	  <property name="username" value="root"/>
	  <property name="password" value="root"/>
	  </bean>
	-->

		<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
	    <property name="locations">
	        <value>classpath:jdbc.properties</value>
	    </property>
		</bean>
	
		<bean id="dataSource" destroy-method="close"
	      class="org.apache.commons.dbcp.BasicDataSource">
	    <property name="driverClassName" value="${jdbc.driverClassName}"/>
	    <property name="url" value="${jdbc.url}"/>
	    <property name="username" value="${jdbc.username}"/>
	    <property name="password" value="${jdbc.password}"/>
		</bean>

<!-- -	<bean id="logInterceptor" class="com.demo.aop.LogInterceptor"></bean> -->

	 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
	    <property name="dataSource" ref="dataSource"/>
	    <property name="annotatedClasses">
	      <list>
	        <value>com.demo.model.User</value>
	        <value>com.demo.model.Log</value>
	      </list>
	    </property>
	    <property name="hibernateProperties">
	    <props>
	     	<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
          	<prop key="hibernate.show_sql">true</prop>
         </props>
	    </property>
	  </bean>
	  
	  <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  	  <property name="sessionFactory" ref="sessionFactory"/>
  	  </bean>
  	
  	  <tx:annotation-driven transaction-manager="txManager"/>
  	
</beans>

/*
    @Transactional //运行时异常会回滚
    public void add(User u) {
        this.userDAO.save(u);
        Log log = new Log();
        log.setMsg("a log saved");
        this.logDAO.save(log);
    }
*/

[java] view plain copy print ?

1. package com.demo.dao;  
2. import com.demo.model.Log;  
3. public interface LogDAO {  
4.     public void save(Log log);  
5. }  

package com.demo.dao;
import com.demo.model.Log;
public interface LogDAO {
	public void save(Log log);
}

[java] view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import javax.annotation.Resource;  
4. import org.hibernate.Session;  
5. import org.hibernate.SessionFactory;  
6. import org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean;  
7. import org.springframework.stereotype.Component;  
8.   
9. import com.demo.dao.LogDAO;  
10. import com.demo.dao.UserDAO;  
11. import com.demo.model.Log;  
12. import com.demo.model.User;  
13.   
14. @Component //就是spring在为这个类生成对象的时候它的key、id、名字是LgDAO   
15. public class LogDAOImpl implements LogDAO {  
16.     private SessionFactory sessionFactory;  
17.     public SessionFactory getSessionFactory() {  
18.         return sessionFactory;  
19.     }  
20.     @Resource  
21.     public void setSessionFactory(SessionFactory sessionFactory) {  
22.         this.sessionFactory = sessionFactory;  
23.     }  
24.       
25.     @Override  
26.     public void save(Log log) {  
27.         Session session = sessionFactory.getCurrentSession();  
28.         session.save(log);  
29.           
30.         //throw new RuntimeException("Error"); Transaction 事物在运行时异常会回滚   
31.     }  
32.   
33. }  

package com.demo.dao.impl;

import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean;
import org.springframework.stereotype.Component;

import com.demo.dao.LogDAO;
import com.demo.dao.UserDAO;
import com.demo.model.Log;
import com.demo.model.User;

@Component //就是spring在为这个类生成对象的时候它的key、id、名字是LgDAO
public class LogDAOImpl implements LogDAO {
	private SessionFactory sessionFactory;
	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}
	@Resource
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
	
	@Override
	public void save(Log log) {
		Session session = sessionFactory.getCurrentSession();
		session.save(log);
		
		//throw new RuntimeException("Error"); Transaction 事物在运行时异常会回滚
	}

}

[java] view plain copy print ?

1. package com.demo.model;  
2.   
3. import javax.persistence.Entity;  
4. import javax.persistence.GeneratedValue;  
5. import javax.persistence.Id;  
6. import javax.persistence.Table;  
7.   
8. @Entity  
9. @Table(name="t_log")  
10. public class Log {  
11.     private int id;  
12.     private String msg;  
13.       
14.     @Id  
15.     @GeneratedValue  
16.     public int getId() {  
17.         return id;  
18.     }  
19.     public void setId(int id) {  
20.         this.id = id;  
21.     }  
22.     public String getMsg() {  
23.         return msg;  
24.     }  
25.     public void setMsg(String msg) {  
26.         this.msg = msg;  
27.     }  
28.       
29.       
30. }  

package com.demo.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="t_log")
public class Log {
	private int id;
	private String msg;
	
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getMsg() {
		return msg;
	}
	public void setMsg(String msg) {
		this.msg = msg;
	}
	
	
}

[java] view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import javax.annotation.Resource;  
4. import org.hibernate.Session;  
5. import org.hibernate.SessionFactory;  
6. import org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean;  
7. import org.springframework.stereotype.Component;  
8. import com.demo.dao.UserDAO;  
9. import com.demo.model.User;  
10.   
11. @Component("u")  
12. public class UserDAOImpl implements UserDAO {  
13.     private SessionFactory sessionFactory;  
14.     public SessionFactory getSessionFactory() {  
15.         return sessionFactory;  
16.     }  
17.     @Resource  
18.     public void setSessionFactory(SessionFactory sessionFactory) {  
19.         this.sessionFactory = sessionFactory;  
20.     }  
21.       
22.     @Override  
23.     public void save(User u) {  
24.         Session session = sessionFactory.getCurrentSession();  
25.         session.save(u);  
26.     }  
27.   
28. }  

package com.demo.dao.impl;

import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean;
import org.springframework.stereotype.Component;
import com.demo.dao.UserDAO;
import com.demo.model.User;

@Component("u")
public class UserDAOImpl implements UserDAO {
	private SessionFactory sessionFactory;
	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}
	@Resource
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
	
	@Override
	public void save(User u) {
		Session session = sessionFactory.getCurrentSession();
		session.save(u);
	}

}

[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. import org.springframework.transaction.annotation.Transactional;  
9.   
10. import com.demo.dao.LogDAO;  
11. import com.demo.dao.UserDAO;  
12. import com.demo.dao.impl.UserDAOImpl;  
13. import com.demo.model.Log;  
14. import com.demo.model.User;  
15. // 面向接口或者抽象编程,需要用谁直接在service 里面new谁 实现DAO接口即可   
16. //面向抽象编程就是 灵活   
17.   
18. @Component("userService")  
19. public class UserService {  
20.     private UserDAO userDAO;  
21.     private LogDAO logDAO;  
22.       
23.       
24.     public LogDAO getLogDAO() {  
25.         return logDAO;  
26.     }  
27.     @Resource  
28.     public void setLogDAO(LogDAO logDAO) {  
29.         this.logDAO = logDAO;  
30.     }  
31.   
32.     public void init() {  
33.         System.out.println("init");  
34.     }  
35.       
36.     public UserDAO getUserDAO() {  
37.         return userDAO;  
38.     }  
39.       
40.     @Resource(name="u") //常用   
41.     public void setUserDAO(UserDAO userDAO) {  
42.         this.userDAO = userDAO;  
43.     }  
44.       
45.     @Transactional //运行时异常会回滚   
46.     public void add(User u) {  
47.         this.userDAO.save(u);  
48.         Log log = new Log();  
49.         log.setMsg("a log saved");  
50.         this.logDAO.save(log);  
51.     }  
52.       
53.     public void destroy() {  
54.         System.out.println("destroy");  
55.     }  
56. }  

package com.demo.service;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import com.demo.dao.LogDAO;
import com.demo.dao.UserDAO;
import com.demo.dao.impl.UserDAOImpl;
import com.demo.model.Log;
import com.demo.model.User;
// 面向接口或者抽象编程,需要用谁直接在service 里面new谁 实现DAO接口即可
//面向抽象编程就是 灵活

@Component("userService")
public class UserService {
	private UserDAO userDAO;
	private LogDAO logDAO;
	
	
	public LogDAO getLogDAO() {
		return logDAO;
	}
	@Resource
	public void setLogDAO(LogDAO logDAO) {
		this.logDAO = logDAO;
	}

	public void init() {
		System.out.println("init");
	}
	
	public UserDAO getUserDAO() {
		return userDAO;
	}
	
	@Resource(name="u") //常用
	public void setUserDAO(UserDAO userDAO) {
		this.userDAO = userDAO;
	}
	
	@Transactional //运行时异常会回滚
	public void add(User u) {
		this.userDAO.save(u);
		Log log = new Log();
		log.setMsg("a log saved");
		this.logDAO.save(log);
	}
	
	public void destroy() {
		System.out.println("destroy");
	}
}

propagation  transaction 的产生过程

[java] view plain copy print ?

1. @Transactional(propagation=Propagation.REQUIRED) //transaction运行时异常会回滚    
2.     //propagation=Propagation.REQUIRED 就是在当前的环境里面如果已经有transaction了就用原来的，没有就创建新的（重要）  

@Transactional(propagation=Propagation.REQUIRED) //transaction运行时异常会回滚 
	//propagation=Propagation.REQUIRED 就是在当前的环境里面如果已经有transaction了就用原来的，没有就创建新的（重要）

用xml的方式配置Transaction (大多数情况下用xml)

[html] view plain copy print ?

1. <!-- 以下是xml 的方式完成声明式的事物 -->    
2.       <aop:config>  
3.         <aop:pointcut id="bussinessService" expression="execution(public * com.demo.service..*.*(..))"/>  
4.         <aop:advisor advice-ref="txAdvice" pointcut-ref="bussinessService"/>  
5.       </aop:config>  
6.       
7.         <tx:advice id="txAdvice" transaction-manager="txManager">  
8.         <tx:attributes>  
9.             <tx:method name="getUser*" read-only="true"/>  
10.             <tx:method name="add*" propagation="REQUIRED"/>  
11.         </tx:attributes>  
12.         </tx:advice>  

<!-- 以下是xml 的方式完成声明式的事物 -->  
	  <aop:config>
	  	<aop:pointcut id="bussinessService" expression="execution(public * com.demo.service..*.*(..))"/>
	  	<aop:advisor advice-ref="txAdvice" pointcut-ref="bussinessService"/>
	  </aop:config>
	
	    <tx:advice id="txAdvice" transaction-manager="txManager">
	    <tx:attributes>
    		<tx:method name="getUser*" read-only="true"/>
    		<tx:method name="add*" propagation="REQUIRED"/>
  		</tx:attributes>
  		</tx:advice>

[html] view plain copy print ?

1. 扫描model此包下面的实体类  
2.   
3. <property name="packagesToScan">  
4.           <list>  
5.             <value>com.demo.model</value>  
6.           </list>  
7.         </property>  

扫描model此包下面的实体类

<property name="packagesToScan">
	      <list>
	        <value>com.demo.model</value>
	      </list>
	    </property>

a)       HibernateTemplate、HibernateCallback、HibernateDaoSupport（不重要）介绍

                       i.             设计模式：TemplateMethod

                     ii.             Callback：回调/钩子函数

                   iii.             第一种：（建议）

1.       在spring中初始化HibernateTemplate，注入sessionFactory

2.       DAO里注入HibernateTemplate

3.       save写getHibernateTemplate.save();

                   iv.             第二种：

1.       从HibernateDaoSupport继承

2.       必须写在xml文件中，无法使用Annotation，因为set方法在父类中，而且是final的

b)       spring整合hibernate的时候使用packagesToScan属性，可以让spring自动扫描对应包下面的实体类

HibernateTemplate  （模板）

[html] view plain copy print ?

1. <bean id="sesssionFactory" class="org.springframework.orm.hibernate3.HibernateTemplate">  
2.             <property name="sessionFactory" ref="sessionFactory"></property>  
3.         </bean>  

<bean id="sesssionFactory" class="org.springframework.orm.hibernate3.HibernateTemplate">
			<property name="sessionFactory" ref="sessionFactory"></property>
		</bean>

[java] view plain copy print ?

1. package com.demo.dao.impl;  
2.   
3. import javax.annotation.Resource;  
4. import org.springframework.orm.hibernate3.HibernateTemplate;  
5. import org.springframework.stereotype.Component;  
6. import com.demo.dao.UserDAO;  
7. import com.demo.model.User;  
8.   
9. @Component("u")  
10. public class UserDAOImpl implements UserDAO {  
11.       
12.     private HibernateTemplate hibernateTemplate;  
13.     public HibernateTemplate getHibernateTemplate() {  
14.         return hibernateTemplate;  
15.     }  
16.     @Resource  
17.     public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {  
18.         this.hibernateTemplate = hibernateTemplate;  
19.     }  
20.   
21.     @Override  
22.     public void save(User u) {  
23.         hibernateTemplate.save(u);  
24.     }  
25.   
26. }  

package com.demo.dao.impl;

import javax.annotation.Resource;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Component;
import com.demo.dao.UserDAO;
import com.demo.model.User;

@Component("u")
public class UserDAOImpl implements UserDAO {
	
	private HibernateTemplate hibernateTemplate;
	public HibernateTemplate getHibernateTemplate() {
		return hibernateTemplate;
	}
	@Resource
	public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
		this.hibernateTemplate = hibernateTemplate;
	}

	@Override
	public void save(User u) {
		hibernateTemplate.save(u);
	}

}

[java] view plain copy print ?

1. <! -- <PRE class=java name="code">HibernateDaoSupport  三种方 不重要</PRE> --><BR>  
2. <BR>  
3. package com.demo.dao.impl;import javax.annotation.Resource;import org.hibernate.SessionFactory;import org.springframework.orm.hibernate3.HibernateTemplate;import org.springframework.orm.hibernate3.support.HibernateDaoSupport;import org.springframework.stereotype.Component;/*@Componentpublic 
4.  class SupportDAO {public HibernateTemplate hibernateTemplate;public HibernateTemplate getHibernateTemplate() {return hibernateTemplate;}@Resourcepublic void setHibernateTemplate(HibernateTemplate hibernateTemplate) {this.hibernateTemplate = hibernateTemplate;}}*//*@Componentpublic 
5.  class SupportDAO extends HibernateDaoSupport{@Resource(name="hibernateTemplate")public void setSupporHibernateTemplate(HibernateTemplate hibernateTemplate) {super.setHibernateTemplate(hibernateTemplate);}}*/@Componentpublic class SupportDAO extends HibernateDaoSupport{@Resource(name="sessionFactory")public  
6.  void setSupportSessionFactory(SessionFactory sessionFactory) {super.setSessionFactory(sessionFactory);}}————————————————————————————————————————————package com.demo.dao.impl;<BR>  
7. <BR>  
8. import javax.annotation.Resource;<BR>  
9. import org.springframework.orm.hibernate3.HibernateTemplate;<BR>  
10. import org.springframework.stereotype.Component;<BR>  
11. import com.demo.dao.UserDAO;<BR>  
12. import com.demo.model.User;<BR>  
13. <BR>  
14. @Component("u")<BR>  
15. public class UserDAOImpl extends SupportDAO implements UserDAO {<BR>  
16.     <BR>  
17.     @Override<BR>  
18.     public void save(User u) {<BR>  
19.         super.getHibernateTemplate().save(u);<BR>  
20.     }<BR>  
21. <BR>  
22. }<BR>  
23. <PRE></PRE>  
24. <P></P>  
25. <PRE></PRE>  
26. <P></P>