wespten

java中spring的使用

　Spring是一个开源框架，框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。

Spring 特点

　①、方便解耦，简化开发

　　通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

　　②、AOP编程的支持

　　通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

　　③、声明式事务的支持

　　在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

　　④、方便程序的测试

　　可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。

　　⑤、方便集成各种优秀框架

　　Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。

　　⑥、降低Java EE API的使用难度

　　Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。

　　⑦、Java 源码是经典学习范例

　　Spring的源码设计精妙、结构清晰、匠心独运，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

Spring 框架结构

1、核心容器：核心容器提供 Spring 框架的基本功能(Spring Core)。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

　　2、Spring 上下文：Spring 上下文是一个配置文件，向 Spring框架提供上下文信息。Spring 上下文包括企业服务，例如JNDI、EJB、电子邮件、国际化、校验和调度功能。

　　3、Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

　　4、Spring DAO：JDBCDAO抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

　　5、Spring ORM：Spring 框架插入了若干个ORM框架，从而提供了 ORM 的对象关系工具，其中包括JDO、Hibernate和iBatisSQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

　　6、Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

　　7、Spring MVC 框架：MVC框架是一个全功能的构建 Web应用程序的 MVC 实现。通过策略接口，MVC框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。模型由javabean构成，存放于Map；视图是一个接口，负责显示模型；控制器表示逻辑代码，是Controller的实现。Spring框架的功能可以用在任何J2EE服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同J2EE 环境（Web 或EJB）、独立应用程序、测试环境之间重用。

Spring 框架特征

轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

　　控制反转——Spring通过一种称作控制反转（IoC）的技术促进了低耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

　　面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

　　容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

　　框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

　　MVC——Spring的作用是整合，但不仅仅限于整合，Spring 框架可以被看做是一个企业解决方案级别的框架。客户端发送请求，服务器控制器（由DispatcherServlet实现的)完成请求的转发，控制器调用一个用于映射的类HandlerMapping，该类用于将请求映射到对应的处理器来处理请求。HandlerMapping 将请求映射到对应的处理器Controller（相当于Action）在Spring 当中如果写一些处理器组件，一般实现Controller 接口，在Controller 中就可以调用一些Service 或DAO 来进行数据操作 ModelAndView 用于存放从DAO 中取出的数据，还可以存放响应视图的一些数据。如果想将处理结果返回给用户，那么在Spring 框架中还提供一个视图组件ViewResolver，该组件根据Controller 返回的标示，找到对应的视图，将响应response 返回给用户。

Spring 优点

Spring能有效地组织你的中间层对象，无论你是否选择使用了EJB。如果你仅仅使用了Struts或其他的包含了J2EE特有APIs的framework，你会发现Spring关注了遗留下的问题。Spring能消除在许多工程上对Singleton的过多使用。根据我的经验，这是一个主要的问题，它减少了系统的可测试性和面向对象特性。

　　Spring能消除使用各种各样格式的属性定制文件的需要，在整个应用和工程中，可通过一种一致的方法来进行配置。曾经感到迷惑，一个特定类要查找迷幻般的属性关键字或系统属性，为此不得不读Javadoc乃至源编码吗？有了Spring，你可很简单地看到类的JavaBean属性。

　　Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。

　　Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。所以使用Spring构建的应用程序易于单元测试。

　　Spring能使EJB的使用成为一个实现选择，而不是应用架构的必然选择。你能选择用POJOs或local EJBs来实现业务接口，却不会影响调用代码。

　　Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适于许多web应用。例如，Spring能使用AOP提供声明性事务而不通过使用EJB容器，如果你仅仅需要与单个的数据库打交道，甚至不需要JTA实现。

　　Spring为数据存取提供了一致的框架，不论是使用JDBC或O/R mapping产品（如Hibernate）。

　　总结：

　　1.低侵入式设计，代码污染极低

　　2.独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once,Run Anywhere的承诺

　　3.Spring的DI机制降低了业务对象替换的复杂性，提高了组件之间的解耦

　　4.Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好的复用

　　5.Spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问

　　6.Spring并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部

IOC-Inversion of Control，即控制反转。它不是什么技术，而是一种设计思想。

　　传统的创建对象的方法是直接通过 new 关键字，而 spring 则是通过 IOC 容器来创建对象，也就是说我们将创建对象的控制权交给了 IOC 容器。我们可以用一句话来概括 IOC：

　　IOC 让程序员不在关注怎么去创建对象，而是关注与对象创建之后的操作，把对象的创建、初始化、销毁等工作交给spring容器来做。

Spring 容器创建对象的三种方式

//这是测试对象，我们通过 IOC 来创建对象
public class HelloIoc {
     
    public void sayHello(){
        System.out.println("Hello IOC");
    }
}

传统的创建对象的方法：new 关键字

//传统的创建对象方法----new
    @Test
    public void testTradition(){
        HelloIoc hello = new HelloIoc();
        hello.sayHello();
    }

这里通过 Spring 容器怎么来创建呢？

　　第一种方法：利用默认的构造方法

　　在 src 目录下新建 applicationContext.xml 文件，这是 spring 配置文件，添加如下代码：

/**
     *  Spring 容器利用构造函数创建对象
     */
    @Test
    public void testCreateObjectByConstrutor(){
        //1、启动 spring 容器
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //2、从 spring 容器中取出数据
        HelloIoc IOC = (HelloIoc) context.getBean("helloIoc");
        //3、通过对象调用方法
        IOC.sayHello();
         
        //利用配置文件 alias 别名属性创建对象
        HelloIoc IOC2 = (HelloIoc) context.getBean("helloIoc2");
        IOC2.sayHello();
    }

HelloIoc.java 中手动添加无参的构造方法，然后执行上面的测试代码，会发现构造方法会在 sayHello()方法执行之前调用。

	public static void main(String[] args) {
		ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
		JavaWork javaWork=(JavaWork)ac.getBean("javaWork");
		javaWork.doTest();
	}

public class JavaWork {
	
	private Tester tester;
	
	public void setTester(Tester tester) {
		this.tester = tester;
	}

	public void doTest(){
		/*ZhangSan zhangsan=new ZhangSan();
		zhangsan.test();*/
		tester.test();
	}
}

第二种方法：利用静态工厂方法

　　首先创建静态工厂类 HelloStaticFactory.java

public class HelloStaticFactory {
    public HelloStaticFactory(){
        System.out.println("HelloStaticFactory constructor");
    }
    //静态工厂方法
    public static HelloIoc getInstances(){
        return new HelloIoc();
    }
 
}

接着在 applicationContext.xml 中进行如下配置：

/**
     * Spring 容器利用静态工厂方法创建对象
     */
    @Test
    public void createObjectStaticFactory(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloIoc staticFactory =
                (HelloIoc) context.getBean("helloStaticFactory");
        staticFactory.sayHello();
    }

spring容器只负责调用静态工厂方法，而这个静态工厂方法内部实现由程序员完成

利用实例工厂方法

　　首先创建实例工厂类 HelloInstanceFactory .java

public class HelloInstanceFactory {
    public HelloInstanceFactory(){
        System.out.println("实例工厂方法构造函数");
    }
 
    //利用实例工厂方法创建对象
    public HelloIoc getInstance(){
        HelloIoc instanceIoc = new HelloIoc();
        return instanceIoc;
    }
}

接着在 applicationContext.xml 中进行如下配置：

/**
     * Spring 容器利用实例工厂方法创建对象
     */
    @Test
    public void createObjectInstanceFactory(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloIoc staticFactory =
                (HelloIoc) context.getBean("instance");
        staticFactory.sayHello();
    }

Spring 容器创建对象的时机

默认情况下，启动 spring 容器便创建对象

在spring的配置文件bean中有一个属性 lazy-init="default/true/false"

　　　　①、如果lazy-init为"default/false"在启动spring容器时创建对象（默认情况）

　　　　 ②、如果lazy-init为"true",在context.getBean时才要创建对象

在第一种情况下可以在启动spring容器的时候，检查spring容器配置文件的正确性，如果再结合tomcat,如果spring容器不能正常启动，整个tomcat就不能正常启动。但是这样的缺点是把一些bean过早的放在了内存中，如果有数据，则对内存来是一个消耗。

　　反过来，在第二种情况下，可以减少内存的消耗，但是不容易发现错误

spring的bean中的scope："singleton/prototype/request/session/global session"

　一、默认scope的值是singleton，即产生的对象是单例的

　　applicationContext.xml 文件中配置：

//spring 容器默认产生对象是单例的 scope="singleton"
    @Test
    public void test_scope_single_CreateObject(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloIoc hello1 = (HelloIoc) context.getBean("helloIoc");
        HelloIoc hello2 = (HelloIoc) context.getBean("helloIoc");
        System.out.println(hello1.equals(hello2)); //true
    }

scope=“prototype”

　　多例模式，并且spring容器启动的时候并不会创建对象，而是在得到 bean 的时候才会创建对象

　　applicationContext.xml 文件中配置：

　总结：在单例模式下，启动 spring 容器，便会创建对象；在多例模式下，启动容器并不会创建对象，获得 bean 的时候才会创建对象

scope=“request” 每次HTTP请求都会创建一个新的bean

scope=“session”同一个HTTP Session共享一个Bean

scope=“global session” 同一个全局Session共享一个Bean，一般用于portlet应用环境

scope=“application”同一个Application 共享一个Bean

Spring 容器生命周期

/**
 * Spring 容器的生命周期
 * @author hadoop
 *
 */
public class SpringLifeCycle {
    public SpringLifeCycle(){
        System.out.println("SpringLifeCycle");
    }
    //定义初始化方法
    public void init(){
        System.out.println("init...");
    }
    //定义销毁方法
    public void destroy(){
        System.out.println("destroy...");
    }
     
    public void sayHello(){
        System.out.println("say Hello...");
    }
}

applicationContext.xml

    public void testSpringLifeCycle(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        SpringLifeCycle hello = (SpringLifeCycle) context.getBean("springLifeCycle");
         
        hello.sayHello();
         
        //销毁spring容器
        ClassPathXmlApplicationContext classContext = (ClassPathXmlApplicationContext) context;
        classContext.close();
    }

spring 容器的声明周期

　　　 1、spring容器创建对象
        　　2、执行init方法
        　　3、调用自己的方法
        　　4、当spring容器关闭的时候执行destroy方法

　　注意：当scope为"prototype"时，调用 close（）方法时是不会调用 destroy 方法的

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class T {

	private ApplicationContext ac;

	@Before
	public void setUp() throws Exception {
		ac=new ClassPathXmlApplicationContext("beans.xml");
	}

	@Test
	public void test1() {
		People people=(People)ac.getBean("people1");
		People people2=(People)ac.getBean("people1");
		System.out.println(people.getDog()==people2.getDog());
		
		System.out.println(ac.getBean("dog")==ac.getBean("dog"));
	}
	

}




	
	
		
	
	
	
	
	
		
		
		
		//方法动态注入
	
	



public abstract class People {

	private int id;
	private String name;
	private int age;
	private Dog dog;
	public abstract Dog getDog();
	
	public void setDog(Dog dog) {
		this.dog = dog;
	}
	@Override
	public String toString() {
		return "People [id=" + id + ", name=" + name + ", age=" + age
				+ ", dog=" + dog.getName() + "]";
	}

}

方法替换

public class People {

	private int id;
	private String name;
	private int age;
	private Dog dog;

	public Dog getDog() {
		Dog dog=new Dog();
		dog.setName("Jack");
		return dog;
	}
	public void setDog(Dog dog) {
		this.dog = dog;
	}
}

public class People2 implements MethodReplacer {

	@Override
	public Object reimplement(Object arg0, Method arg1, Object[] arg2)
			throws Throwable {
		Dog dog=new Dog();
		dog.setName("Tom");
		return dog;
	}

}

DI依赖注入

spring动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
 
public class Person {
    private Long pid;
    private String pname;
    private Student students;
    private List lists;
    private Set sets;
    private Map maps;
    private Properties properties;
}

在 applicationContext.xml 中进行赋值



    
    
    
        
    
  //注入bean
//级联private Student students=new Student()

    
     
    
        
            1
            
            vae
        
    
     
    
        
            1
            
            vae
        
    
     
    
        
            
            
                
            
        
       
     
    
        
            p1
            p2

//利用 set 方法给对象赋值
    @Test
    public void testSet(){
        //1、启动 spring 容器
        //2、从 spring 容器中取出数据
        //3、通过对象调用方法
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person");
        System.out.println(person.getPname());//vae
    }

利用构造函数给属性赋值

在实体类 Person.java 中添加两个构造方法：有参和无参

//默认构造函数
    public Person(){}
    //带参构造函数
    public Person(Long pid,Student students){
        this.pid = pid;
        this.students = students;
    }

在 applicationContext.xml 中进行赋值

//利用 构造函数 给对象赋值
    @Test
    public void testConstrutor(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person_con");
        System.out.println(person.getPid());//1
    }

　　1、如果spring的配置文件中的bean中没有该元素，则调用默认的构造函数

　　2、如果spring的配置文件中的bean中有该元素，则该元素确定唯一的构造函数

构造方法通过类型注入

public class People {

	private int id;
	private String name;
	private int age;
	
	
	
	public People() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	
	
	
	public People(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
}

自动装配

byName通过名称自动匹配





	
		
	

	
	
		
	
	
	
	
	
		
		
		
	
	
	



public class People {

	private int id;
	private String name;
	private int age;
	private Dog dog;
}

byType:通过类型进行自动匹配

constructor;根据类型，自动注入




	
		
	
	
	
	
	
		
		
		
	
	
	



public class People {

	private int id;
	private String name;
	private int age;
	private Dog dog;

	public People() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	
	public People(Dog dog) {
		super();
		System.out.println("constructor");
		this.dog = dog;
	}
}

bean之间的关系

继承

public class T {

	private ApplicationContext ac;

	@Before
	public void setUp() throws Exception {
		ac=new ClassPathXmlApplicationContext("beans.xml");
	}

	@Test
	public void test1() {
		People zhangsan=(People)ac.getBean("zhangsan");
		System.out.println(zhangsan);
		
		People lisi=(People)ac.getBean("lisi");
		System.out.println(lisi);
	}
	

}

依赖

使用注解，让 Spring 容器帮我们产生 Person 对象

使用注解

在 applicationContext.xml 中引入命名空间

引入的命名空间，简单来说就是用来约束xml文件格式的。第一个 xmlns:context ，这表示标签格式应该是

在 applicationContext.xml 文件中引入注解扫描器

base-package：表示含有注解类的包名

　如果扫描多个包，则上面的代码书写多行，改变 base-package 里面的内容即可！

　　@Component

　　如果一个类上加了@Component注解，就会进行如下的法则

        　　　　　　如果其value属性的值为""

             　　　　　　 @Component

             　　　　　　 public class Person {}

              　　　　　　　　等价于

              　　　　　　

      　　　　　　 如果其value属性的值不为""

             　　　　　　 @Component("p")

              　　　　　　public class Person {}

             　　　　　　　　等价于

在 Person 类中添加注解@Component

    public void testAnnotation(){
        //1、启动 spring 容器
        //2、从 spring 容器中取出数据
        //3、通过对象调用方法
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person");
        System.out.println(person.getPname());
    }

@Repository ：dao层
@Service：service层
@Controller：web层

注解 @Resource

@Resource 注解，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。通过 @Resource 的使用来消除 set ，get方法。

　　@Resource注解以后，判断该注解name的属性是否为""(name没有写)

　　　　①、如果没有写name属性，则会让属性的名称的值和spring配置文件bean中ID的值做匹配（如果没有进行配置，也和注解@Component进行匹配），如果匹配成功则赋值，如果匹配不成功，则会按照spring配置文件class类型进行匹配，如果匹配不成功，则报错

　　　　②、如果有name属性，则会按照name属性的值和spring的bean中ID进行匹配，匹配成功，则赋值，不成功则报错

不使用注解：

使用注解：

注解 @Autowired

功能和注解 @Resource 一样，可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。只不过注解@Resource 是按照名称来进行装配，而@Autowired 则是按照类型来进行装配。

　在使用@Autowired时，首先在容器中查询对应类型的bean

　　　　如果查询结果刚好为一个，就将该bean装配给@Autowired指定的数据

　　　　如果查询的结果不止一个，那么@Autowired会根据名称来查找。

　　　　如果查询的结果为空，那么会抛出异常。解决方法时，使用required=false

创建接口 PersonDao

public interface PersonDao {
     
    public void savePerson();
 
}

创建一个接口实现类 PersonDaoImplOne

import org.springframework.stereotype.Component;
 
@Component("personDaoImplOne")
public class PersonDaoImplOne implements PersonDao{
 
    @Override
    public void savePerson() {
        System.out.println("save Person One");
         
    }
 
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service("personService")
public class PersonService{
    @Autowired
    private PersonDao personDao;
     
    public void savePerson() {
        this.personDao.savePerson();
    }
 
}

　　注意：这里我们在 private PesronDao personDao 上面添加了注解 @Autowired，它首先会根据类型去匹配，PersonDao 是一个接口，它的实现类是 PesronDaoImpOne，那么这里的意思就是：

　　PersonDao personDao = new PersonDaoImpOne();

　　那么问题来了，如果 PersonDao 的实现类有多个呢？我们创建第一个实现类 PersonDaoImpTwo

第一种方法：更改名称

　第二种方法：@Autowired 和 @Qualifier("名称") 配合使用

AOP（Aspect Oriented Programming），通常称为面向切面编程。它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

静态代理

增加和删除操作都必须要开启事务，操作完成之后要提交事务。

public interface UserService {
    //添加 user
    public void addUser(User user);
    //删除 user
    public void deleteUser(int uid);
}

创建 UserService的实现类

public class UserServiceImpl implements UserService{
    @Override
    public void addUser(User user) {
        System.out.println("增加 User");
    }
    @Override
    public void deleteUser(int uid) {
        System.out.println("删除 User");
    }
}

创建事务类 MyTransaction

public class MyTransaction {
    //开启事务
    public void before(){
        System.out.println("开启事务");
    }
    //提交事务
    public void after(){
        System.out.println("提交事务");
    }
}

创建代理类 ProxyUser.java

public class ProxyUser implements UserService{
    //真实类
    private UserService userService;
    //事务类
    private MyTransaction transaction;
    //使用构造函数实例化
    public ProxyUser(UserService userService,MyTransaction transaction){
        this.userService = userService;
        this.transaction = transaction;
    }
    @Override
    public void addUser(User user) {
        transaction.before();
        userService.addUser(user);
        transaction.after();
    }
    @Override
    public void deleteUser(int uid) {
        transaction.before();
        userService.deleteUser(uid);
        transaction.after();       
    }
}

@Test
    public void testOne(){
        MyTransaction transaction = new MyTransaction();
        UserService userService = new UserServiceImpl();
        //产生静态代理对象
        ProxyUser proxy = new ProxyUser(userService, transaction);
        proxy.addUser(null);
        proxy.deleteUser(0);
    }

业务类UserServiceImpl 只需要关注业务逻辑本身，保证了业务的重用性，这也是代理类的优点

这样写的缺点：

　①、代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。

　　②、如果接口增加一个方法，比如 UserService 增加修改 updateUser(）方法，则除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

使用JDK动态代理

　动态代理就不要自己手动生成代理类了，我们去掉 ProxyUser.java 类，增加一个 ObjectInterceptor.java 类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
 
import com.my.aop.one.MyTransaction;
 
public class ObjectInterceptor implements InvocationHandler{
    //目标类
    private Object target;
    //切面类（这里指事务类）
    private MyTransaction transaction;
     
    //通过构造器赋值
    public ObjectInterceptor(Object target,MyTransaction transaction){
        this.target = target;
        this.transaction = transaction;
    }
     
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //开启事务
        this.transaction.before();
        //调用目标类方法
        method.invoke(this.target, args);
        //提交事务
        this.transaction.after();
        return null;
    }
     
}

@Test
    public void testOne(){
        //目标类
        Object target = new UserServiceImpl();
        //事务类
        MyTransaction transaction = new MyTransaction();
        ObjectInterceptor proxyObject = new ObjectInterceptor(target, transaction);
        /**
         * 三个参数的含义：
         * 1、目标类的类加载器
         * 2、目标类所有实现的接口
         * 3、拦截器
         */
        UserService userService = (UserService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), proxyObject);
        userService.addUser(null);
    }

后期在 UserService 中增加业务方法，都不用更改代码就能自动给我们生成代理对象。而且将 UserService 换成别的类也是可以的。

　　也就是做到了代理对象能够代理多个目标类，多个目标方法。

　　注意：我们这里使用的是 JDK 动态代理，要求是必须要实现接口。与之对应的另外一种动态代理实现模式 Cglib，则不需要，我们这里就不讲解 cglib 的实现方式了。

AOP 关键术语

　1.target：目标类，需要被代理的类。例如：UserService

　　2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法

　　3.PointCut 切入点：已经被增强的连接点。例如：addUser()

　　4.advice 通知/增强，增强代码。例如：after、before

　　5. Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.

　　6.proxy 代理类：通知+切入点

　　7. Aspect(切面): 是切入点pointcut和通知advice的结合

　　具体可以根据下面这张图来理解：

AOP 的通知类型　　

　　Spring按照通知Advice在目标类方法的连接点位置，可以分为5类

前置通知 org.springframework.aop.MethodBeforeAdvice
- 在目标方法执行前实施增强，比如上面例子的 before()方法
后置通知 org.springframework.aop.AfterReturningAdvice
- 在目标方法执行后实施增强，比如上面例子的 after()方法
环绕通知 org.aopalliance.intercept.MethodInterceptor
- 在目标方法执行前后实施增强
异常抛出通知 org.springframework.aop.ThrowsAdvice
- 在方法抛出异常后实施增强
引介通知 org.springframework.aop.IntroductionInterceptor

　　　　　　在目标类中添加一些新的方法和属性

　我们只需要在Spring 的配置文件 applicationContext.xml 进行如下配置

@Test
    public void testAop(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService useService = (UserService) context.getBean("userService");
        useService.addUser(null);
    }

　①、切入点表达式，一个完整的方法表示如下：

execution（modifiers-pattern? ref-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?）
                类修饰符           返回值           方法所在的包                  方法名                     方法抛出的异常

那么根据上面的对比，我们就很好理解：

execution(* com.my.aop.*.*(..))
选择方法         返回值任意   包             类名任意   方法名任意   参数任意

　那么它表达的意思是返回值任意，包名为 com.ys.aop 下的任意类名中的任意方法名，参数任意。

如果切入点表达式有多个不同目录呢？

表示匹配 com.my包下的，以 Service1结尾或者以Service2结尾的类的任意方法。

　AOP 切入点表达式支持多种形式的定义规则：

1、execution:匹配方法的执行（常用）
        execution(public *.*(..))
2.within:匹配包或子包中的方法(了解)
    within(com.my.aop..*)
3.this:匹配实现接口的代理对象中的方法(了解)
    this(com.my.aop.user.UserDAO)
4.target:匹配实现接口的目标对象中的方法(了解)
    target(com.my.aop.user.UserDAO)
5.args:匹配参数格式符合标准的方法(了解)
    args(int,int)
6.bean(id)  对指定的bean所有的方法(了解)
    bean('userServiceId')

②、springAOP 的具体加载步骤：

　　1、当 spring 容器启动的时候，加载了 spring 的配置文件

　　2、为配置文件中的所有 bean 创建对象

　　3、spring 容器会解析 aop:config 的配置

　　　　1、解析切入点表达式，用切入点表达式和纳入 spring 容器中的 bean 做匹配

　　　　如果匹配成功，则会为该 bean 创建代理对象，代理对象的方法=目标方法+通知

　　　　如果匹配不成功，不会创建代理对象

　　4、在客户端利用 context.getBean() 获取对象时，如果该对象有代理对象，则返回代理对象；如果没有，则返回目标对象

　　　　说明：如果目标类没有实现接口，则 spring 容器会采用 cglib 的方式产生代理对象，如果实现了接口，则会采用 jdk 的方式

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class StudentServiceAspect {

	public void doBefore(JoinPoint jp){
		System.out.println("类名:"+jp.getTarget().getClass().getName());
		System.out.println("方法名："+jp.getSignature().getName());
		System.out.println("开始添加学生："+jp.getArgs()[0]);
	}
	
	public void doAfter(JoinPoint jp){
		System.out.println("类名:"+jp.getTarget().getClass().getName());
		System.out.println("方法名："+jp.getSignature().getName());
		System.out.println("学生添加完成："+jp.getArgs()[0]);
	}
	
	public Object doAround(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("添加学生前");
		Object retVal=pjp.proceed();
		System.out.println(retVal);
		System.out.println("添加学生后");
		return retVal;
	}
	
	public void doAfterReturning(JoinPoint jp){
		System.out.println("返回通知");
	}
	
	public void doAfterThrowing(JoinPoint jp,Throwable ex){
		System.out.println("异常通知");
		System.out.println("异常信息："+ex.getMessage());
	}
}

public class StudentServiceImpl implements StudentService{

	@Override
	public void addStudent(String name) {
		// System.out.println("开始添加学生"+name);
		System.out.println("添加学生"+name);
		System.out.println(1/0);
		// System.out.println("完成学生"+name+"的添加");
	}

}

AspectJ是一个面向切面的框架，它扩展了Java语言。

Aspect 通知类型，定义了类型名称以及方法格式。类型如下：

    before:前置通知(应用：各种校验)
    在方法执行前执行，如果通知抛出异常，阻止方法运行
afterReturning:后置通知(应用：常规数据处理)
    方法正常返回后执行，如果方法中抛出异常，通知无法执行
    必须在方法执行后才执行，所以可以获得方法的返回值。
around:环绕通知(应用：十分强大，可以做任何事情)
    方法执行前后分别执行，可以阻止方法的执行
    必须手动执行目标方法
afterThrowing:抛出异常通知(应用：包装异常信息)
    方法抛出异常后执行，如果方法没有抛出异常，无法执行
after:最终通知(应用：清理现场)
    方法执行完毕后执行，无论方法中是否出现异常

这里最重要的是around,环绕通知，它可以代替上面的任意通知。

在程序中表示的意思如下：

try{
     //前置：before
    //手动执行目标方法
    //后置：afterRetruning
} catch(){
    //抛出异常 afterThrowing
} finally{
    //最终 after
}

AOP具体实例

public interface UserService {
    //添加 user
    public void addUser();
    //删除 user
    public void deleteUser();
}

创建实现类

public class UserServiceImpl implements UserService{
    @Override
    public void addUser() {
        System.out.println("增加 User");
    }
    @Override
    public void deleteUser() {
        System.out.println("删除 User");
    }
}

创建切面类（包含各种通知）

import org.aspectj.lang.JoinPoint;
 
 
public class MyAspect {
    /**
     * JoinPoint 能获取目标方法的一些基本信息
     * @param joinPoint
     */
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    }
     
    public void myAfterReturning(JoinPoint joinPoint,Object ret){
        System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    }
     
    public void myAfter(){
        System.out.println("最终通知");
    }
 
}

创建spring配置文件applicationContext.xml

@Test
    public void testAop(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService useService = (UserService) context.getBean("userService");
        useService.addUser();
    }

测试异常通知

public void addUser() {
        int i = 1/0;//显然这里会抛出除数不能为 0
        System.out.println("增加 User");
    }

切面类

public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("抛出异常通知 ： " + e.getMessage());
    }

@Test
    public void testAop(){
        String str = "com/my/execption/applicationContext.xml";
        ApplicationContext context = new ClassPathXmlApplicationContext(str);
        UserService useService = (UserService) context.getBean("userService");
        useService.addUser();
    }

测试环绕通知

public class MyAspect {
     
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("前置通知");
        //手动执行目标方法
        Object obj = joinPoint.proceed();
         
        System.out.println("后置通知");
        return obj;
    }
 
}

applicationContext.xml 配置如下：

通过 xml 配置的方式。

@Test
    public void testAop(){
        String str = "com/my/around/applicationContext.xml";
        ApplicationContext context = new ClassPathXmlApplicationContext(str);
        UserService useService = (UserService) context.getBean("userService");
        useService.addUser();
    }

注解实现 AOP

　@Aspect 声明切面，修饰切面类，从而获得通知。

　　通知

　　　　@Before 前置

　　　　@AfterReturning 后置

　　　　@Around 环绕

　　　　@AfterThrowing 抛出异常

　　　　@After 最终

　　切入点

　　　　@PointCut ，修饰方法 private void xxx(){} 之后通过“方法名”获得切入点引用

在 applicationContext.xml 文件中导入相应的命名空间

注解配置 bean

　xml配置：

配置扫描注解识别

在 applicationContext.xml 文件中添加如下配置：

在切面类上添加 @Aspect 注解，如下：

告诉 Spring 哪个是切面类

如何让 Spring 认识我们所配置的 AOP 注解呢

　我们在 applicationContext.xml 文件中增加如下配置：

注解配置前置通知

　　我们先看 xml 配置前置通知如下：

那么注解的方式如下：

注解配置后置通知

　　xml 配置后置通知：

注意看，后置通知有个 returning="ret" 配置，这是用来获得目标方法的返回值的。

    public void testAopAnnotation(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext_Annotation.xml");
        UserService useService = (UserService) context.getBean("userService");
        useService.addUser();
        useService.deleteUser();
    }

注解改进　　

声明公共切入点：

　　①、在切面类 MyAspect.java 中新增一个切入点方法 myPointCut()，然后在这个方法上添加 @Pointcut 注解

事务（Transaction），一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。

　　这里我们以取钱的例子来讲解：比如你去ATM机取1000块钱，大体有两个步骤：第一步输入密码金额，银行卡扣掉1000元钱；第二步从ATM出1000元钱。这两个步骤必须是要么都执行要么都不执行。如果银行卡扣除了1000块但是ATM出钱失败的话，你将会损失1000元；如果银行卡扣钱失败但是ATM却出了1000块，那么银行将损失1000元。

　　如何保证这两个步骤不会出现一个出现异常了，而另一个执行成功呢？事务就是用来解决这样的问题。事务是一系列的动作，它们综合在一起才是一个完整的工作单元，这些动作必须全部完成，如果有一个失败的话，那么事务就会回滚到最开始的状态，仿佛什么都没发生过一样。在企业级应用程序开发中，事务管理是必不可少的技术，用来确保数据的完整性和一致性。

事务的四个特性（ACID）

　①、原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。

　　②、一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。

　　③、隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。

　　④、持久性（Durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中。

PlatformTransactionManager 事务管理器

　Spring事务管理器的接口是org.springframework.transaction.PlatformTransactionManager，Spring并不直接管理事务，通过这个接口，Spring为各个平台如JDBC、Hibernate等都提供了对应的事务管理器，也就是将事务管理的职责委托给Hibernate或者JTA等持久化机制所提供的相关平台框架的事务来实现。

也就是说Spring事务管理的为不同的事务API提供一致的编程模型，具体的事务管理机制由对应各个平台去实现。

　AccountDao 接口：

public interface AccountDao {
    /**
     * 汇款
     * @param outer 汇款人
     * @param money 汇款金额
     */
    public void out(String outer,int money);
     
    /**
     * 收款
     * @param inner 收款人
     * @param money 收款金额
     */
    public void in(String inner,int money);

import org.springframework.jdbc.core.support.JdbcDaoSupport;
 
import com.my.dao.AccountDao;
 
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
 
    /**
     * 根据用户名减少账户金额
     */
    @Override
    public void out(String outer, int money) {
        this.getJdbcTemplate().update("update account set money = money - ? where username = ?",money,outer);
    }
 
    /**
     * 根据用户名增加账户金额
     */
    @Override
    public void in(String inner, int money) {
        this.getJdbcTemplate().update("update account set money = money + ? where username = ?",money,inner);
    }
 
}

public interface AccountService {
     
    /**
     * 转账
     * @param outer 汇款人
     * @param inner 收款人
     * @param money 交易金额
     */
    public void transfer(String outer,String inner,int money);
 
}

public class AccountServiceImpl implements AccountService{
 
    private AccountDao accountDao;
     
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    @Override
    public void transfer(String outer, String inner, int money) {
        accountDao.out(outer, money);
        accountDao.in(inner, money);
    }
 
}

public class TransactionTest {
     
    @Test
    public void testNoTransaction(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        AccountService account = (AccountService) context.getBean("accountService");
        //Tom 向 Marry 转账1000
        account.transfer("Tom", "Marry", 1000);
    }
 
}

　编程式事务处理：所谓编程式事务指的是通过编码方式实现事务，允许用户在代码中精确定义事务的边界。即类似于JDBC编程实现事务管理。管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。

　　声明式事务处理：管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。

　　简单地说，编程式事务侵入到了业务代码里面，但是提供了更加详细的事务管理；而声明式事务由于基于AOP，所以既能起到事务管理的作用，又可以不影响业务代码的具体实现。

编程式事务处理实现转账（TransactionTemplate ）

我们在 Service 层注入 TransactionTemplate 模板，因为是用模板来管理事务，所以模板需要注入事务管理器 DataSourceTransactionManager 。而事务管理器说到底还是用底层的JDBC在管理，所以我们需要在事务管理器中注入 DataSource。这几个步骤分别如下：

AccountServiceImpl 接口：

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;
 
import com.my.dao.AccountDao;
import com.my.service.AccountService;
 
public class AccountServiceImpl implements AccountService{
 
    private AccountDao accountDao;
    private TransactionTemplate transactionTemplate;
     
    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
        this.transactionTemplate = transactionTemplate;
    }
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    @Override
    public void transfer(final String outer,final String inner,final int money) {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus arg0) {
                accountDao.out(outer, money);
                //int i = 1/0;
                accountDao.in(inner, money);
            }
        });
    }
 
}

　Spring 全局配置文件 applicationContext.xml：

底层的PlatformTransactionManager来进行事务管理

//定义一个某个框架平台的TransactionManager，如JDBC、Hibernate
        DataSourceTransactionManager dataSourceTransactionManager =
                new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(this.getJdbcTemplate().getDataSource()); // 设置数据源
     
        DefaultTransactionDefinition transDef = new DefaultTransactionDefinition(); // 定义事务属性
        transDef.setPropagationBehavior(DefaultTransactionDefinition.PROPAGATION_REQUIRED); // 设置传播行为属性
        TransactionStatus status = dataSourceTransactionManager.getTransaction(transDef); // 获得事务状态
        try {
            // 数据库操作
            accountDao.out(outer, money);
            int i = 1/0;
            accountDao.in(inner, money);
             
            dataSourceTransactionManager.commit(status);// 提交
        } catch (Exception e) {
            dataSourceTransactionManager.rollback(status);// 回滚
        }

声明式事务处理实现转账（基于AOP的 xml 配置）

　Dao 层和 Service 层与我们最先开始的不用事务实现转账保持不变。主要是 applicationContext.xml 文件变化了。

　　我们在 applicationContext.xml 文件中配置 aop 自动生成代理，进行事务管理：

　　①、配置管理器

　　②、配置事务详情

　　③、配置 aop

　一、传播行为：当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。

　　　　Spring 定义了如下七中传播行为，这里以A业务和B业务之间如何传播事务为例说明：

　　①、PROPAGATION_REQUIRED ：required , 必须。默认值，A如果有事务，B将使用该事务；如果A没有事务，B将创建一个新的事务。

　　②、PROPAGATION_SUPPORTS：supports ，支持。A如果有事务，B将使用该事务；如果A没有事务，B将以非事务执行。

　　③、PROPAGATION_MANDATORY：mandatory ，强制。A如果有事务，B将使用该事务；如果A没有事务，B将抛异常。

　　④、PROPAGATION_REQUIRES_NEW ：requires_new，必须新的。如果A有事务，将A的事务挂起，B创建一个新的事务；如果A没有事务，B创建一个新的事务。

　　⑤、PROPAGATION_NOT_SUPPORTED ：not_supported ,不支持。如果A有事务，将A的事务挂起，B将以非事务执行；如果A没有事务，B将以非事务执行。

　　⑥、PROPAGATION_NEVER ：never，从不。如果A有事务，B将抛异常；如果A没有事务，B将以非事务执行。

　　⑦、PROPAGATION_NESTED ：nested ，嵌套。A和B底层采用保存点机制，形成嵌套事务。

　　二、隔离级别：定义了一个事务可能受其他并发事务影响的程度。

　　并发事务引起的问题：

　　　　在典型的应用程序中，多个事务并发运行，经常会操作相同的数据来完成各自的任务。并发虽然是必须的，但可能会导致以下的问题。

　　　　①、脏读（Dirty reads）——脏读发生在一个事务读取了另一个事务改写但尚未提交的数据时。如果改写在稍后被回滚了，那么第一个事务获取的数据就是无效的。

　　　　②、不可重复读（Nonrepeatable read）——不可重复读发生在一个事务执行相同的查询两次或两次以上，但是每次都得到不同的数据时。这通常是因为另一个并发事务在两次查询期间进行了更新。

　　　　③、幻读（Phantom read）——幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着另一个并发事务（T2）插入了一些数据时。在随后的查询中，第一个事务（T1）就会发现多了一些原本不存在的记录。

　　　　注意：不可重复读重点是修改，而幻读重点是新增或删除。

　　在 Spring 事务管理中，为我们定义了如下的隔离级别：

　　①、ISOLATION_DEFAULT：使用后端数据库默认的隔离级别

　　②、ISOLATION_READ_UNCOMMITTED：最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读

　　③、ISOLATION_READ_COMMITTED：允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生

　　④、ISOLATION_REPEATABLE_READ：对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生

　　⑤、ISOLATION_SERIALIZABLE：最高的隔离级别，完全服从ACID的隔离级别，确保阻止脏读、不可重复读以及幻读，也是最慢的事务隔离级别，因为它通常是通过完全锁定事务相关的数据库表来实现的

　　上面定义的隔离级别，在 Spring 的 TransactionDefinition.class 中也分别用常量 -1,0,1,2,4,8表示。

　三、只读

　　这是事务的第三个特性，是否为只读事务。如果事务只对后端的数据库进行该操作，数据库可以利用事务的只读特性来进行一些特定的优化。通过将事务设置为只读，你就可以给数据库一个机会，让它应用它认为合适的优化措施。

　　四、事务超时

　　为了使应用程序很好地运行，事务不能运行太长的时间。因为事务可能涉及对后端数据库的锁定，所以长时间的事务会不必要的占用数据库资源。事务超时就是事务的一个定时器，在特定时间内事务如果没有执行完毕，那么就会自动回滚，而不是一直等待其结束。

　　五、回滚规则

　　事务五边形的最后一个方面是一组规则，这些规则定义了哪些异常会导致事务回滚而哪些不会。默认情况下，事务只有遇到运行期异常时才会回滚，而在遇到检查型异常时不会回滚（这一行为与EJB的回滚行为是一致的）。但是你可以声明事务在遇到特定的检查型异常时像遇到运行期异常那样回滚。同样，你还可以声明事务遇到特定的异常不回滚，即使这些异常是运行期异常。

声明式事务处理实现转账（基于AOP的注解配置）　

分为如下两步：

　　①、在applicationContext.xml 配置事务管理器，将并事务管理器交予spring

　　②、在目标类或目标方法添加注解即可 @Transactional

　　首先在 applicationContext.xml 文件中配置如下：

　其次在目标类或者方法添加注解@Transactional。如果在类上添加，则说明类中的所有方法都添加事务，如果在方法上添加，则只有该方法具有事务。

import javax.annotation.Resource;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
 
import com.my.dao.AccountDao;
import com.my.service.AccountService;
 
@Transactional(propagation=Propagation.REQUIRED , isolation = Isolation.DEFAULT)
@Service("accountService")
public class AccountServiceImpl implements AccountService{
    @Resource(name="accountDao")
    private AccountDao accountDao;
     
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    @Override
    public void transfer(String outer, String inner, int money) {
        accountDao.out(outer, money);
        //int i = 1/0;
        accountDao.in(inner, money);
    }
 
}

spring对jdbc的支持

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


import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;


public class StudentDaoImpl implements StudentDao{

	private JdbcTemplate jdbcTemplate;
	
	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}

	@Override
	public int addStudent(Student student) {
		String sql="insert into t_student values(null,?,?)";
		Object []params=new Object[]{student.getName(),student.getAge()};
		return jdbcTemplate.update(sql,params);
	}

	@Override
	public int updateStudent(Student student) {
		String sql="update t_student set name=?,age=? where id=?";
		Object []params=new Object[]{student.getName(),student.getAge(),student.getId()};
		return jdbcTemplate.update(sql,params);
	}

	@Override
	public int deleteStudent(int id) {
		String sql="delete from t_student where id=?";
		Object []params=new Object[]{id};
		return jdbcTemplate.update(sql,params);
	}

	@Override
	public List findStudents() {
		String sql="select * from t_student";
		final List studentList=new ArrayList();
		jdbcTemplate.query(sql, new RowCallbackHandler(){

			@Override
			public void processRow(ResultSet rs) throws SQLException {
				Student student=new Student();
				student.setId(rs.getInt("id"));
				student.setName(rs.getString("name"));
				student.setAge(rs.getInt("age"));
				studentList.add(student);
			}
			
		});
		return studentList;
	}

}

import java.util.List;

public class StudentServiceImpl implements StudentService{

	private StudentDao studentDao;
	
	public void setStudentDao(StudentDao studentDao) {
		this.studentDao = studentDao;
	}

	@Override
	public int addStudent(Student student) {
		return studentDao.addStudent(student);
	}

	@Override
	public int updateStudent(Student student) {
		return studentDao.updateStudent(student);
	}

	@Override
	public int deleteStudent(int id) {
		return studentDao.deleteStudent(id);
	}

	@Override
	public List findStudents() {
		return studentDao.findStudents();
	}

import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class T {

	private ApplicationContext ac;

	@Before
	public void setUp() throws Exception {
		ac=new ClassPathXmlApplicationContext("beans.xml");
	}

	@Test
	public void addStudent() {
		StudentService studentService=(StudentService)ac.getBean("studentService");
		int addNums=studentService.addStudent(new Student("王五", 1));
		if(addNums==1){
			System.out.println("添加成功");
		}
	}
	
	@Test
	public void updateStudent() {
		StudentService studentService=(StudentService)ac.getBean("studentService");
		int updateNums=studentService.updateStudent(new Student(8,"王五2", 2));
		if(updateNums==1){
			System.out.println("更新成功");
		}
	}
	
	@Test
	public void deleteStudent() {
		StudentService studentService=(StudentService)ac.getBean("studentService");
		int deleteNums=studentService.deleteStudent(8);
		if(deleteNums==1){
			System.out.println("删除成功");
		}
	}
	
	@Test
	public void findStudents() {
		StudentService studentService=(StudentService)ac.getBean("studentService");
		List studentList=studentService.findStudents();
		for(Student student:studentList){
			System.out.println(student);
		}
	}

}

支持命名参数变量

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;

public class StudentDaoImpl implements StudentDao{

	private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
	
	public void setNamedParameterJdbcTemplate(
			NamedParameterJdbcTemplate namedParameterJdbcTemplate) {
		this.namedParameterJdbcTemplate = namedParameterJdbcTemplate;
	}

	@Override
	public int addStudent(Student student) {
		String sql="insert into t_student values(null,:name,:age)";
		MapSqlParameterSource sps=new MapSqlParameterSource();
		sps.addValue("name", student.getName());
		sps.addValue("age", student.getAge());
		return namedParameterJdbcTemplate.update(sql,sps);
	}

	@Override
	public int updateStudent(Student student) {
		String sql="update t_student set name=:name,age=:age where id=:id";
		MapSqlParameterSource sps=new MapSqlParameterSource();
		sps.addValue("name", student.getName());
		sps.addValue("age", student.getAge());
		sps.addValue("id", student.getId());
		return namedParameterJdbcTemplate.update(sql,sps);
	}

	@Override
	public int deleteStudent(int id) {
		String sql="delete from t_student where id=:id";
		MapSqlParameterSource sps=new MapSqlParameterSource();
		sps.addValue("id", id);
		return namedParameterJdbcTemplate.update(sql,sps);
	}

	@Override
	public List findStudents() {
		String sql="select * from t_student";
		final List studentList=new ArrayList();
		namedParameterJdbcTemplate.query(sql, new RowCallbackHandler(){

			@Override
			public void processRow(ResultSet rs) throws SQLException {
				Student student=new Student();
				student.setId(rs.getInt("id"));
				student.setName(rs.getString("name"));
				student.setAge(rs.getInt("age"));
				studentList.add(student);
			}
			
		});
		return studentList;
	}

}

import java.util.List;

public class StudentServiceImpl implements StudentService{

	private StudentDao studentDao;
	
	public void setStudentDao(StudentDao studentDao) {
		this.studentDao = studentDao;
	}

	@Override
	public int addStudent(Student student) {
		return studentDao.addStudent(student);
	}

	@Override
	public int updateStudent(Student student) {
		return studentDao.updateStudent(student);
	}

	@Override
	public int deleteStudent(int id) {
		return studentDao.deleteStudent(id);
	}

	@Override
	public List findStudents() {
		return studentDao.findStudents();
	}
}

spring整合hibernate

web,xml



  S2SH
  
    index.jsp
  
  
    
    
    contextConfigLocation  
    classpath:applicationContext.xml  
    
    
    
      
        org.springframework.web.context.ContextLoaderListener  
      
      
    
    
    struts2  
    org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter  
     
  
    
    struts2  
    /*  
    
  
   
     
    openSessionInViewFilter  
    org.springframework.orm.hibernate4.support.OpenSessionInViewFilter  
      
      singleSession  
      true  
      
    
    
     
    openSessionInViewFilter  
    *.action

struts.xml

  
  
      
  
      
      
    
    	
    		/success.jsp
    		/index.jsp

hibernate.cfg.xml

  
  
  
  
      
		
		
        org.hibernate.dialect.MySQL5Dialect  

          
        true  
        
		
        update

applicationContext.xml

    
    
  
    
    
		
		
		
		
		
		
	
      
      
      
          
              
          
          
          
          
              
                com.java.entity  //包下的所有类都会扫描
              
          
      
  
      
      
          
      
  
      
      
          
          
              
              
              
              
              
              
              
              
              
              
              
              
              
              
          
      
      
   
      
      
          
          
      
  
      
      //配置的类全部注解

实体

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

import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="t_user")
public class User {

	private Integer id;
	private String userName;
	private String password;

	
	@Id
	@GenericGenerator(name = "generator", strategy = "native")
	@GeneratedValue(generator = "generator")
	@Column(name = "id", length=11)
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	@Column(name = "userName", length = 20)
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	@Column(name = "password", length = 20)
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	
}

import java.io.Serializable;
import java.util.List;

/**
 * 基础数据库操作类
 * 
 * 
 */
public interface BaseDao {

	/**
	 * 保存一个对象
	 * 
	 * @param o
	 * @return
	 */
	public Serializable save(T o);

	/**
	 * 删除一个对象
	 * 
	 * @param o
	 */
	public void delete(T o);

	/**
	 * 更新一个对象
	 * 
	 * @param o
	 */
	public void update(T o);

	/**
	 * 保存或更新对象
	 * 
	 * @param o
	 */
	public void saveOrUpdate(T o);

	/**
	 * 查询
	 * 
	 * @param hql
	 * @return
	 */
	public List find(String hql);

	/**
	 * 查询集合
	 * 
	 * @param hql
	 * @param param
	 * @return
	 */
	public List find(String hql, Object[] param);

	/**
	 * 查询集合
	 * 
	 * @param hql
	 * @param param
	 * @return
	 */
	public List find(String hql, List

java中spring的使用

你可能感兴趣的:(经典后端)