Spring
提供了一站式解决方案：
1） Spring Core spring的核心功能： IOC容器, 解决对象创建及依赖关系
2） Spring Web Spring对web模块的支持。
-à
可以与struts整合,让struts的action创建交给spring
-à spring mvc
模式
3） Spring DAO Spring 对jdbc操作的支持 【JdbcTemplate模板工具类】
4
） Spring ORM spring对orm的支持：
à
既可以与hibernate整合，【session】
à
也可以使用spring的对hibernate操作的封装
5）Spring AOP 切面编程
6
）SpringEE spring 对javaEE其他模块的支持
目标：
1
） 代理模式
静态代理
动态代理
Cglib
代理
2
）手动实现AOP编程 【代理模式】
3
）AOP编程
*
注解方式实现
* XMl
配置方式实现
4
） Spring DAO
Spring对jdbc操作的支持
1. 代理模式
1.1 概述
代理（Proxy）是一种设计模式， 提供了对目标对象另外的访问方式；即通过代理访问目标对象。 这样好处： 可以在目标对象实现的基础上，增强额外的功能操作。(扩展目标对象的功能)。
举例：明星（邓紫棋）ß---经纪人<-------用户
目标 （代理）
代理模式的关键点： 代理对象与目标对象。
1.2 静态代理
静态代理，
1
） 代理对象，要实现与目标对象一样的接口；
2
） 举例:
保存用户(模拟)
Dao ,
直接保存
DaoProxy,
给保存方法添加事务处理
总结静态代理：
1
）可以做到在不修改目标对象的功能前提下，对目标对象功能扩展。
2
）缺点：
--
》 因为代理对象，需要与目标对象实现一样的接口。所以会有很多代理类，类太多。
--
》 一旦接口增加方法，目标对象与代理对象都要维护。
解决：
代理工厂？ 可以使用动态代理。
1.3 动态代理
动态代理，
1
）代理对象，不需要实现接口；
2
）代理对象的生成，是利用JDKAPI， 动态的在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型；);
3)
动态代理， JDK代理， 接口代理；
JDK
中生成代理对象的API：
|-- Proxy
static Object newProxyInstance(
ClassLoader loader,
指定当前目标对象使用类加载器
Class<?>[] interfaces,
目标对象实现的接口的类型
InvocationHandler h
事件处理器
)
动态代理总结：
代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！
(class $Proxy0 implements IuserDao)
思考：
有一个目标对象，想要功能扩展，但目标对象没有实现接口，怎样功能扩展？
Class UserDao{}
//
子类的方式
Class subclass extends UserDao{}
以子类的方式实现(cglib代理)
1.4 Cglib代理
Cglib
代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。
l
JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。
l
CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
l
CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。
Cglib
子类代理：
1)
需要引入cglib – jar文件， 但是spring的核心包中已经包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。
2
）引入功能包后，就可以在内存中动态构建子类
3
）代理的类不能为final， 否则报错。
4
） 目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法。
在Spring的AOP编程中，
如果加入容器的目标对象有实现接口，用JDK代理；
如果目标对象没有实现接口，用Cglib代理；
2. 手动实现AOP编程
AOP
面向切面的编程，
AOP
可以实现“业务代码”与“关注点代码”分离
分析总结：
关注点代码，就是指重复执行的代码。
业务代码与关注点代码分离，好处？
--à
关注点代码写一次即可；
-à
开发者只需要关注核心业务；
-à
运行时期，执行核心业务代码时候动态植入关注点代码； 【代理】
如何分离？
过程式/对象式/代理模式分离
3. AOP编程
3.1 概述：
Aop， aspect object programming 面向切面编程
功能： 让关注点代码与业务代码分离！
关注点,
重复代码就叫做关注点；
切面，
关注点形成的类，就叫切面类！切面类一般用于，日志、安全、权限方面使用。
面向切面编程，就是指 对很多功能都有的重复的代码抽取，再在运行的时候网业务方法上动态植入“切面类代码”。切面中的方法叫通知。
切入点，(相当于条件)
执行目标对象方法，动态植入切面代码。
可以通过切入点表达式，指定拦截哪些类的哪些方法； 给指定的类在运行的时候植入切面类代码。
3.2 注解方式实现AOP编程
步骤：
1
） 先引入aop相关jar文件 （aspectj aop优秀组件）
spring-aop-3.2.5.RELEASE.jar
【spring3.2源码】
aopalliance.jar
【spring2.5源码/lib/aopalliance】
aspectjweaver.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】
aspectjrt.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】
注意： 用到spring2.5版本的jar文件，如果用jdk1.7可能会有问题。
需要升级aspectj组件，即使用aspectj-1.8.2版本中提供jar文件提供。
2
） bean.xml中引入aop名称空间
3
） 开启aop注解
4)
使用注解
@Aspect
指定一个类为切面类
@Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")
指定切入点表达式 （相当于条件）
@Before("pointCut_()")
前置通知: 目标方法之前执行
@After("pointCut_()")
后置通知：目标方法之后执行（始终执行）
@AfterReturning("pointCut_()")
返回后通知： 执行方法结束前执行(异常不执行)
@AfterThrowing("pointCut_()")
异常通知: 出现异常时候执行
@Around("pointCut_()")
环绕通知： 环绕目标方法执行
3.3 XML方式实现AOP编程
Xml
实现aop编程：
1
） 引入jar文件 【aop 相关jar， 4个】
2
） 引入aop名称空间
3
）aop 配置
*
配置切面类 （重复执行代码形成的类）
* aop
配置
拦截哪些方法 / 拦截到方法后应用通知代码
3.4 切入点表达式
切入点表达式,
可以对指定的“方法”进行拦截； 从而给指定的方法所在的类生层代理对象。
4. Spring对jdbc支持
使用步骤：
1
）引入jar文件
spring-jdbc-3.2.5.RELEASE.jar
spring-tx-3.2.5.RELEASE.jar
2
） 优化
< aop:aspect>和< aop:advisor>的区别
- < aop:aspect>：定义AOP通知器、大多用于日志，缓存
- < aop:advisor>：定义切面、大多用于事务管理。
比如，下面是一个对Service包上所有方法的切面配置
<aop:config>
<aop:pointcut id="serviceOperation"
expression="execution(* *..service*..*(..))"/>
<aop:advisor pointcut-ref="serviceOperation"
advice-ref="txAdvice"/>
</aop:config>
表达式所处位置如上pointcut的位置。
配置这个为了更好控制切面上的事务，下面是一个事物配置的简单例子：
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="delete*" rollback-for="Exception"/>
<tx:method name="save*" rollback-for="Exception"/>
<tx:method name="update*" rollback-for="Exception"/>
<tx:method name="*" read-only="true" rollback-for="Exception"/>
</tx:attributes>
</tx:advice>
通过切面、通知的配置，就为所有的delete/save/update开头的方法添加上了一致性事务，对其他方法添加上了只读事务。
表示
service包下的所有方法为为事务管理。
spring与hibernate整合
1、注入SessionFactory方式
1、在配置文件中，引入sessionFactory。
<!--
引入sessionFactory 方法一
-->
<bean id="sessionFactory1" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
<!--
引入sessionFactory 方法二
-->
<bean id="sessionFactory2" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!--
映射文件所在的路径
-->
<property name="mappingDirectoryLocations">
<list>
<!--
spring容器会去该包及子包下搜索所有的映射文件
-->
<value>com/itheima12/spring/hibernate/transaction/domain</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
2、继承HibernateDaoSupport
public class PersonDaoImpl extends HibernateDaoSupport implements PersonDao{
public void savePerson(Person person) {
// TODO Auto-generated method stub
this.getHibernateTemplate().save(person);
}
}
2、注入HibernateTemplate方式
配置文件如下所示：
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
DAO编码如下所示：
private HibernateTemplate hibernateTemplate;
// 定义一个Logger，便于它及其子类计入日志用
protected Logger logger = Logger.getLogger(this.getClass());
public HibernateTemplate getHibernateTemplate() {
return hibernateTemplate;
}
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
@Override
public <T> void saveEntity(T entity) {
// TODO Auto-generated method stub
this.hibernateTemplate.saveOrUpdate(entity);
}
3、注入jdbcTemplate方式
这种配置是使用
Spring对JDBC的封装，而非Hibernate。即不加载Hibernate容器，直接使用Spring对JDBC的封装来操作数据库
第一种配置：给DAO类注入数据源dataSource
配置如下:
Xml代码
- <bean id="userManageImpl" class="com.nos.business.springJDBC.impl.UserManageImpl">
- <property name="dataSource" ref="dataSource" />
- </bean>
DAO编码如下所示：
Java代码
- public class UserManageImpl implements IUserManage{
- private JdbcTemplate jdbcTemplate;
- @Resource(name="dataSource")
- public void setDataSource(DataSource dataSource){
- this.jdbcTemplate = new JdbcTemplate(dataSource);
- }
- @Override
- public void add(UserVo vo)
- {
- jdbcTemplate.update("insert into user_info(name,sex) values(?,?)", new Object[]{vo.getName(), vo.getSex()});
- }
- }
第二种配置：直接给Dao类注入JdbcTemplate
配置如下：
Xml代码
- <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
- <property name="dataSource" ref="dataSource" />
- </bean>
DAO编码如下所示：
Java代码
- public class UserManageImpl2 implements IUserManage{
- @Resource
- private JdbcTemplate jdbcTemplate;
- @Override
- public void add(UserVo vo)
- {
- jdbcTemplate.update("insert into user_info(name,sex) values(?,?)", new Object[]{vo.getName(), vo.getSex()});
- }
- }
spring的声明式事务处理：
(让程序员不再关注事务)
声明：由程序告诉spring容器，什么样的目标方法采用什么样的事务策略
事务处理：是由spring容器来完成的
crud操作：程序员做的事情
1、XML方式实现声明式事务处理
以下是声明式事务处理的例子：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
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
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">
<!--
引入properties配置文件
-->
<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>
<!--
引入sessionFactory
-->
<bean id="sessionFactory1" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
<bean id="sessionFactory2" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!--
映射文件所在的路径
-->
<property name="mappingDirectoryLocations">
<list>
<!--
spring容器会去该包及子包下搜索所有的映射文件
-->
<value>com/itheima12/spring/hibernate/transaction/domain</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
<bean id="personDao" class="com.itheima12.spring.hibernate.transaction.dao.impl.PersonDaoImpl">
<property name="sessionFactory">
<ref bean="sessionFactory2"/>
</property>
</bean>
<bean id="personService" class="com.itheima12.spring.hibernate.transaction.service.impl.PersonServiceImpl">
<property name="personDao">
<ref bean="personDao"/>
</property>
</bean>
<!--
事务管理器
-->
<bean id="
transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory2"/>
</property>
</bean>
<!--
事务的声明
-->
<tx:advice transaction-manager="
transactionManager" id="tx">
<tx:attributes>
<!--
name: 目标方法的范围
isolation 隔离机制
propagation 传播属性 解决事务的嵌套问题
read-only
true 只读事务
false 读写事务
-->
<tx:method name="save*" isolation="DEFAULT" propagation="REQUIRED"
read-only="false"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut
expression="execution(* com.itheima12.spring.hibernate.transaction.service.impl.*.*(..))"
id="perform"/>
<aop:advisor advice-ref="tx" pointcut-ref="perform"/>
</aop:config>
</beans>
2、注解方式实现方式 实现声明式事务处理
使用注解实现Spring的声明式事务管理，更加简单！
步骤：
1
） 必须引入Aop相关的jar文件
2
） bean.xml中指定注解方式实现声明式事务管理以及应用的事务管理器类
3
）在需要添加事务控制的地方，写上: @Transactional
@Transactional
注解：
1
）应用事务的注解
2
）定义到方法上： 当前方法应用spring的声明式事务
3
）定义到类上： 当前类的所有的方法都应用Spring声明式事务管理;
4
）定义到父类上： 当执行父类的方法时候应用事务。
Bean.xm
<?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:p="http://www.springframework.org/schema/p"
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.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 1. 数据源对象: C3P0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
<property name="initialPoolSize" value="3"></property>
<property name="maxPoolSize" value="10"></property>
<property name="maxStatements" value="100"></property>
<property name="acquireIncrement" value="2"></property>
</bean>
<!-- 2. JdbcTemplate工具类实例 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 事务管理器类 -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 开启注解扫描 -->
<context:component-scan base-package="cn.itcast.b_anno"></context:component-scan>
<!-- 注解方式实现事务： 指定注解方式实现事务 -->
<tx:annotation-driven transaction-manager="txManager"/>
</beans>
DeptService
@Service
public class DeptService {
@Resource
private DeptDao deptDao;
/*
* 事务控制？
*/
@Transactional
public void save(Dept dept){
deptDao.save(dept);
int i = 1/0;
deptDao.save(dept);
}
}
事务属性
@Transactional(
readOnly = false, // 读写事务
timeout = -1, // 事务的超时时间不限制
noRollbackFor = ArithmeticException.class, // 遇到数学异常不回滚
isolation = Isolation.DEFAULT, // 事务的隔离级别，数据库的默认
propagation = Propagation.REQUIRED // 事务的传播行为
)
public void save(Dept dept){
deptDao.save(dept);
int i = 1/0;
deptDao.save(dept);
}
Spring HibernateTransactionManager事物管理类
我们在Spring里通常把事务交给HibernateTransactionManager来处理，通过Aop配置事务，把事务交给该类之后就会
由该类来帮我们管理和提供事务。
<context:annotation- config/>的作用：
使用<context:annotation- config/>隐式地向 Spring容器注册AutowiredAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor以及PersistenceAnnotationBeanPostProcessor这4个BeanPostProcessor。
因为： 使用@Autowired注解，必须事先在Spring容器中声明AutowiredAnnotationBeanPostProcessor的Bean：
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor "/>