Spring学习第二天——代理对象，AOP，Spring与JDBC结合，spring要与hibernate版本对应
AOP:访问——>代理对象(判断)——>目标对象执行
1、AOP——代理对象
静态代理，动态代理。多用动态代理
横切性关注点：拦截与相应的处理
(1)、传统代理对象
JDK的代理类创建代理对象：
Proxy，要求目标对象必须实现了接口！
JDKProxyFactory.java：
package cn.itcast.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import cn.itcast.service.impl.PersonServiceBean;
public class JDKProxyFactory implements InvocationHandler{
private Object targetObject;
public Object createProxyIntance(Object targetObject){
this.targetObject = targetObject;
/*
* 第一个参数设置代码使用的类装载器,一般采用跟目标类相同的类装载器
* 第二个参数设置代理类实现的接口
* 第三个参数设置回调对象,当代理对象的方法被调用时,会委派给该参数指定对象的invoke方法
*/
return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),
this.targetObject.getClass().getInterfaces(), this);
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {//环绕通知
PersonServiceBean bean = (PersonServiceBean) this.targetObject;
Object result = null;
if(bean.getUser()!=null){
//..... advice()-->前置通知
try {
result = method.invoke(targetObject, args);
// afteradvice() -->后置通知
} catch (RuntimeException e) {
//exceptionadvice()--> 例外通知
}finally{
//finallyadvice(); -->最终通知
}
}
return result;
}
}
接口不是类，不能使用new 运算符实例化一个接口。如 x=new comparable（......）;//这个是错误来的。但是可以声明接口变量Comparable x; //这是允许的。
测试app：
@Test public void proxyTest(){
JDKProxyFactory factory = new JDKProxyFactory();
PersonService service = (PersonService) factory.createProxyIntance(new PersonServiceBean("xxx"));
service.save("888");
}如果没有实现接口，那么可以使用第三方：CGLIB生成代理
public class CGLIBProxy implements MethodInterceptor {
private Object targetObject;//代理的目标对象
public Object createProxyInstance(Object targetObject){
this.targetObject = targetObject;
Enhancer enhancer = new Enhancer();//该类用于生成代理对象
enhancer.setSuperclass(this.targetObject.getClass());//设置父类
enhancer.setCallback(this);//设置回调用对象为本身
return enhancer.create();
}
public Object intercept(Object proxy, Method method, Object[] args,
MethodProxy methodProxy) throws Throwable {
return methodProxy.invoke(this.targetObject, args);
}
}
测试app：
@Test public void proxyTest2(){
CGlibProxyFactory factory = new CGlibProxyFactory();
PersonServiceBean service = (PersonServiceBean) factory.createProxyIntance(new PersonServiceBean("xxx"));
service.save("999");
}Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面横切性关注点的抽象.
joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)
Pointcut(切入点):所谓切入点是指我们要对那些joinpoint进行拦截的定义.
Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知
Target(目标对象):代理的目标对象
Weave(织入):指将aspects应用到target对象并导致proxy对象创建的过程称为织入.
Introduction(引入):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field(是代理对象).
spring就是利用上面的两种方式进行的代理封装(实现了接口就使用JDK的，没实现接口的就采用CGLIB)。
(2)、Spring中的AOP
Spring提供了两种切面声明方式，实际工作中我们可以选用其中一种：- 基于XML配置方式声明切面。
- 基于注解方式声明切面。
注解方式：
@Aspect @Compotent
public class LogPrint {
@Pointcut("execution(* cn.itcast.service..*.*(..))")
private void anyMethod() {}//声明一个切入点
@Before("anyMethod() && args(userName)")//定义前置通知
public void doAccessCheck(String userName) {
}
@AfterReturning(pointcut="anyMethod()",returning="revalue")//定义后置通知
public void doReturnCheck(String revalue) {
}
@AfterThrowing(pointcut="anyMethod()", throwing="ex")//定义例外通知
public void doExceptionAction(Exception ex) {
}
@After("anyMethod()")//定义最终通知
public void doReleaseAction() {
}
@Around("anyMethod()")//环绕通知
public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
return pjp.proceed();
}
}cn.itcast.service.. 包名，子包底下的类也进行拦截
*.*(..) 所有的类、所有的方法、任意参数
@Pointcut("execution (* cn.itcast.service.impl.PersonServiceBean.*(..))")出现意外通知，后置通知就不会执行了。
@Aspect@Compotent
XML配置方式：
先声明一个切面类：public class LogPrint {
public void doAccessCheck() {}定义前置通知
public void doReturnCheck() {}定义后置通知
public void doExceptionAction() {}定义例外通知
public void doReleaseAction() {}定义最终通知
public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
return pjp.proceed();环绕通知
}
}
2、spring与JDBC
命名空间：
(1)、数据源的配置：
(2)、配置事务：
(A)、利用注解方式(推荐使用)：
@Transactional标注的位置
@Transactional注解可以标注在类和方法上，也可以标注在定义的接口和接口方法上。
如果我们在接口上标注@Transactional注解，会留下这样的隐患：因为注解不能被继承，所以业务接口中标注的@Transactional注解不会被业务实现类继承。所以可能会出现不启动事务的情况。所以，Spring建议我们将@Transaction注解在实现类上。
在方法上的@Transactional注解会覆盖掉类上的@Transactional。
@Transactional注解可以标注在类和方法上，也可以标注在定义的接口和接口方法上。
如果我们在接口上标注@Transactional注解，会留下这样的隐患：因为注解不能被继承，所以业务接口中标注的@Transactional注解不会被业务实现类继承。所以可能会出现不启动事务的情况。所以，Spring建议我们将@Transaction注解在实现类上。
在方法上的@Transactional注解会覆盖掉类上的@Transactional。
@Transactional之value
value这里主要用来指定不同的事务管理器；主要用来满足在同一个系统中，存在不同的事务管理器。比如在Spring中，声明了两种事务管理器txManager1, txManager2.
然后，用户可以根据这个参数来根据需要指定特定的txManager.
那有同学会问什么情况下会存在多个事务管理器的情况呢？ 比如在一个系统中，需要访问多个数据源或者多个数据库，则必然会配置多个事务管理器的。
value这里主要用来指定不同的事务管理器；主要用来满足在同一个系统中，存在不同的事务管理器。比如在Spring中，声明了两种事务管理器txManager1, txManager2.
然后，用户可以根据这个参数来根据需要指定特定的txManager.
那有同学会问什么情况下会存在多个事务管理器的情况呢？ 比如在一个系统中，需要访问多个数据源或者多个数据库，则必然会配置多个事务管理器的。
如果我们要程序中使用多个事务管理器（主要是针对多数据源的情况），可以通过以下的方式实现：
Service代码：
Service代码：
public class MultiTxService {
@Transactional("tran_1")
public void addTest(int id){
}
@Transactional("tran_2")
public void deleteTest(int id){
}
}applicationContext.xml配置如下：
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Transactional("tran_1")
public @interface CustomerTransactional {
}//使用名为tran_1的事务管理器
@CustomerTransactional
public void addTest(String str){
}
…package cn.itcast.service.impl;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;
import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;
@Service @Transactional
public class PersonServiceBean implements PersonService {
private JdbcTemplate jdbcTemplate;
@Resource
public void setDataSource(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
public void delete(Integer personid) {
jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
new int[]{java.sql.Types.INTEGER});
}
public Person getPerson(Integer personid) {
return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid},
new int[]{java.sql.Types.INTEGER}, new PersonRowMapper());
}
@SuppressWarnings("unchecked")
public List getPersons() {
return (List)jdbcTemplate.query("select * from person", new PersonRowMapper());
}
public void save(Person person) {
jdbcTemplate.update("insert into person(name) values(?)", new Object[]{person.getName()},
new int[]{java.sql.Types.VARCHAR});
}
public void update(Person person) {
jdbcTemplate.update("update person set name=? where id=?", new Object[]{person.getName(), person.getId()},
new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});
}
}
Spring管理事务：
RuntimeException会自动回滚
checked的异常不会回滚try catch
可以通过设置来决定是否回滚
@Transactional(rollbackFor=Exception.class)
public void delete(Integer personid) throws Exception{
jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
new int[]{java.sql.Types.INTEGER});
throw new Exception("运行期例外");
}@Transactional(propagation=Propagation.NOT_SUPPORTED)
public Person getPerson(Integer personid) {
return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid},
new int[]{java.sql.Types.INTEGER}, new PersonRowMapper());
}事务传播属性：
- REQUIRED：业务方法需要在一个事务中运行。如果方法运行时，已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务。(大多数都是这种行为，也是默认行为)
- NOT_SUPPORTED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。
- REQUIRESNEW：属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务会被挂起，新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复执行。
- MANDATORY：该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用，容器就会抛出例外。
- SUPPORTS：这一事务属性表明，如果业务方法在某个事务范围内被调用，则方法成为该事务的一部分。如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行。
- Never：指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出例外，只有业务方法没有关联到任何事务，才能正常执行。
- NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按REQUIRED属性执行.它使用了一个单独的事务， 这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效
readOnly="true" 事务设置为只读属性
isolation 事务隔离级别
数据库系统提供了四种事务隔离级别供用户选择。不同的隔离级别采用不同的锁类型来实现，在四种隔离级别中，Serializable的隔离级别最高，Read Uncommited的隔离级别最低。大多数据库默认的隔离级别为Read Commited，如SqlServer，当然也有少部分数据库默认的隔离级别为Repeatable Read ，如Mysql
简单的增删查改：
作用域整个application范围，如果想要获得spring容器可以通过提供的类进行获得
我们通过下面语句获取spring容器实例：
WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(this.getServlet().getServletContext());
数据库系统提供了四种事务隔离级别供用户选择。不同的隔离级别采用不同的锁类型来实现，在四种隔离级别中，Serializable的隔离级别最高，Read Uncommited的隔离级别最低。大多数据库默认的隔离级别为Read Commited，如SqlServer，当然也有少部分数据库默认的隔离级别为Repeatable Read ，如Mysql
- Read Uncommited：读未提交数据(会出现脏读,不可重复读和幻读)。
- Read Commited：读已提交数据(会出现不可重复读和幻读)
- Repeatable Read：可重复读(会出现幻读)
- Serializable：串行化
- 脏读：一个事务读取到另一事务未提交的更新新据。
- 不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同。换句话说就是，后续读取可以读到另一事务已提交的更新数据。相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是，后续读取不能读到另一事务已提交的更新数据。
- 幻读：一个事务读取到另一事务已提交的insert数据。
(B)、利用xml文件配置事务：
简单的增删查改：
@Override
public void save(Person person){
Session session = sessionFactory.getCurrentSession();
session.persist(person);
}
@Override
//实体bean已经成为游离状态
public void update(Person person){
Session session = sessionFactory.getCurrentSession();
session.merge(person);
}
@Override
@Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = true)
public Person getPerson(Integer id){
Session session = sessionFactory.getCurrentSession();
Person person = (Person) session.get(Person.class, id);
return person;
}
@Override
public void delete(Integer id){
Session session = sessionFactory.getCurrentSession();
Person person = (Person) session.load(Person.class, id);
session.delete(person);
}
@Override
@Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = true)
public List getPerson(){
Session session = sessionFactory.getCurrentSession();
List list = session.createQuery("FROM seu.xinci.pojo.Person").list();
return list;
} 3、spring4与hibernate4(加入二级缓存与连接池的配置)
在web容器中实例化spring容器：
通过listener实例化spring容器
contextConfigLocation
classpath:beans.xml
org.springframework.web.context.ContextLoaderListener
作用域整个application范围，如果想要获得spring容器可以通过提供的类进行获得
WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(this.getServlet().getServletContext());
POM文件：
4.0.0
com.springapp
Spring_test
war
1.0-SNAPSHOT
Spring_test
4.1.1.RELEASE
org.springframework
spring-core
${spring.version}
org.springframework
spring-web
${spring.version}
javax.servlet
servlet-api
2.5
javax.servlet.jsp
jsp-api
2.1
provided
org.springframework
spring-webmvc
${spring.version}
org.springframework
spring-test
${spring.version}
test
org.springframework
spring-orm
${spring.version}
junit
junit
4.11
test
org.hibernate
hibernate-core
4.1.1.Final
org.apache.commons
commons-dbcp2
2.1
mysql
mysql-connector-java
5.1.34
com.google.code.gson
gson
2.3.1
Spring_test
maven-compiler-plugin
1.6
1.6
maven-surefire-plugin
**/*Tests.java
web.xml文件：
contextConfigLocation
classpath:mvc-dispatcher-servlet.xml
org.springframework.web.context.ContextLoaderListener
encodingFilter
org.springframework.web.filter.CharacterEncodingFilter
encoding
UTF-8
forceEncoding
true
encodingFilter
/*
spring
org.springframework.web.servlet.DispatcherServlet
contextConfigLocation
classpath:mvc-dispatcher-servlet.xml
1
spring
/
mvc-dispatcher-servlet.xml：
classpath:data.properties
seu.xinci.pojo
${hibernate.hbm2ddl.auto}
${hibernate.dialect}
${hibernate.show_sql}
data.properties：
##
chat.driverClassName=com.mysql.jdbc.Driver
chat.url=jdbc:mysql://localhost:3306/test2
chat.username=root
chat.password=1234
hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
hibernate.show_sql=true
hibernate.hbm2ddl.auto=updatespring4+hibernate4利用注解方式
配置二级缓存：
pom.xml文件：添加三个依赖：
org.hibernate
hibernate-ehcache
4.1.1.Final
org.slf4j
slf4j-api
1.7.12
第三行尤其重要，因为使用的是hibernate4，与网上大多数的3配置不同
${hibernate.cache.use_second_level_cache}
${hibernate.cache.use_query_cache}
${hibernate.cache.factory_class} hibernate.cache.use_second_level_cache=true
hibernate.cache.use_query_cache=false
hibernate.cache.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory然后在类路径下加入ehcache.xml文件：
配置工作都已经完成了，最后别忘记
在要进行二级缓存的类上面加注释
@Entity
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
@Table(name = "person")
public class Person {}这样就可以使用了。
spring4+hibernate4解决乱码问题
在web.xml文件中加入以下代码：
encodingFilter
org.springframework.web.filter.CharacterEncodingFilter
encoding
UTF-8
forceEncoding
true
encodingFilter
/*
横跨servlet与jsp
使用spring解决hibernate因session关闭导致的延迟加载例外问题。
OpenSessionInViewFilter
org.springframework.orm.hibernate4.support.OpenSessionInViewFilter
OpenSessionInViewFilter
/*
4、spring4与JPA（加入二级缓存与连接池的配置）
学习完了spring与hibernate后，又出来了一个spring与JPA，但貌似还是用的hibernate的JPA。。。。听说JPA是一种规范，更适合移植，因此又对此作了些研究，好在配置还算简单。
文件结构：
重点是persistence.xml文件的位置，是在类目录下的名叫“META-INF”目录下， 名字跟位置都是固定的，不知道为什么，规定
pom.xml文件：
4.0.0
com.springapp
spring_jpa
war
1.0-SNAPSHOT
spring_jpa
4.1.1.RELEASE
org.springframework
spring-core
${spring.version}
org.springframework
spring-web
${spring.version}
javax.servlet
servlet-api
2.5
javax.servlet.jsp
jsp-api
2.1
provided
org.springframework
spring-webmvc
${spring.version}
org.springframework
spring-test
${spring.version}
test
junit
junit
4.11
test
org.springframework
spring-orm
${spring.version}
org.hibernate
hibernate-entitymanager
4.1.1.Final
org.slf4j
slf4j-api
1.7.12
mysql
mysql-connector-java
5.1.34
org.hibernate
hibernate-ehcache
4.1.1.Final
org.hibernate
hibernate-c3p0
4.1.1.Final
spring_jpa
maven-compiler-plugin
1.6
1.6
maven-surefire-plugin
**/*Tests.java
web的配置与前面的配置一样。与hibernate的主要不同是spring的xml文件跟persistence.xml
spring的xml文件：
至于perisistence文件个人感觉跟没有与spring结合的hibernate的配置差不多。
PersonServiceBean:(不是很规范应该写成DAO的)：
package seu.xinci.service.impl;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import seu.xinci.pojo.Person;
import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;
/**
* Created by Administrator on 2015-12-24.
*/
@Service
@Transactional
public class PersonServiceBean implements seu.xinci.service.PersonService {
@PersistenceContext
EntityManager em;
@Override
public void save(Person person){
em.persist(person);
}
@Override
//实体bean已经成为游离状态
public void update(Person person){
em.merge(person);
}
@Override
@Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = true)
public Person getPerson(Integer id){
Person person = em.find(Person.class,id);
return person;
}
@Override
@Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = true)
public Person getPersonByName(String t_name){
Person person = (Person) em.createQuery(
"SELECT t FROM seu.xinci.pojo.Person t WHERE t.name = :u_name ")
.setParameter("u_name", t_name)
.getSingleResult();
return person;
}
@Override
public void delete(Integer id){
em.remove(em.getReference(Person.class, id));
}
@Override
@Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = true)
public List getPersons(){
List list = em.createQuery("SELECT o FROM seu.xinci.pojo.Person o").getResultList();
return list;
}
}
注意：3.5版本之后不用在导入hibernate-annotations.jar这个包,hibernate-core已经集成了.
下面开始spring MVC的学习，fighting！