Spring框架总结

一   spring常用的三种注入方式(setter方法注入，构造器注入，自动装配)

1 setter方法注入，在类中一定要写属性的setter方法。

<bean  id="helloword"  class="com.wengde.spring.bean.HelloWord">
    <property name="name2" value="wangwu"></property>
</bean>

 <bean id="person" class="com.wengde.spring.bean.Person" scope="singleton">
     <property name="name" value="zhangsan"></property>
     <property name="age" value="26"></property>
     <property name="car" ref="car2"></property>
</bean>

id是bean的名字，具有唯一性，在同一个xml文件中id名字不能重复，class是全类名，所以必须要有无参构造器。name是类的属性名，也就是要和类的属性名一致。通过scope(singleton,prototype,request,session)来决定bean的作用域。通过ref来映射其他的bean。

2 构造器注入

<bean id="car" class="com.wengde.spring.bean.Car">
    <constructor-arg value="Baoma" index="0"></constructor-arg>
    <constructor-arg value="red" index="1"></constructor-arg>
    <constructor-arg value="3000" type="double"></constructor-arg>
</bean>

如果出现构造器参数个数一样的重载构造器，可以通过type来区分构造器参数的类型。

 3 自动装配，通过注解@@Autowired 注入，可以用于属性（不用再写setter方法），构造器和setter方法

public class TestBean12 {  
    @Autowired //字段注入  
    private String message;  
    //省略getter和setter  
} 

二、依赖注入——自动装配

  在应用中，我们常常使用<ref>标签为JavaBean注入它依赖的对象,同时也Spring为我们提供了一个自动装配的机制，在定义Bean时，<bean>标签有一个autowire属性，我们可以通过指定它来让容器为受管JavaBean自动注入依赖对象。

自动装配是在配置文件中实现的，如下：<bean id="***" class="***" autowire="byType">

1.byName：按名称装配  可以根据属性的名称在容器中查询与该属性名称相同的bean，也就是bean的id值要和类的属性名称一致，如果没有找到，则属性值为null。假设Person类中有一个名为car和address的属性，如果容器中刚好有一个名为car和adress的Bean，Spring就会自动将其装配给Boss的car属性。

 <bean id="address" class="com.wengde.spring.autowire.Address">
     <property name="city" value="shenzhen"></property>   
     <property name="street" value="huangnikan"></property>   
 </bean>
 <bean id="car" class="com.wengde.spring.autowire.Car" >
     <property name="pingpa" value="baoma"></property>
     <property name="price" value="300000"></property>
 </bean>
 <bean id="person" class="com.wengde.spring.autowire.Person" autowire="byName">
    <property name="name" value="lijing"></property>
 </bean>

2.byType：按类型装配  可以根据属性类型，在容器中寻找该类型匹配的bean，如有多个，则会抛出异常，如果没有找到，则属性值为null。假设Boss类中有一个Car类型的属性，如果容器中刚好有一个Car类型的Bean，Spring就会自动将其装配给Boss的这个属性。

     根据属性Property的数据类型自动装配，这种情况，Customer设置了autowire="byType"，Spring会总动寻找与属性类型相同的bean，找到后，通过调用setPerson(Person person)将其注入。

<bean id="customer" class="com.lei.common.Customer" autowire="byType" />
<bean id="person" class="com.lei.common.Person" />

如果配置文件中有两个类型相同的bean会怎样呢？如下：

<bean id="customer" class="com.lei.common.Customer" autowire="byType" />
<bean id="person" class="com.lei.common.Person" />
<bean id="person_another" class="com.lei.common.Person" />

一旦配置如上，有两种相同数据类型的bean被配置，将抛出UnsatisfiedDependencyException异常，见以下：
Exception in thread "main" org.springframework.beans.factory.UnsatisfiedDependencyException: 
所以，一旦选择了“byType”类型的自动装配，请确认你的配置文件中每个数据类型定义一个唯一的bean。

三 集合参数注入

list集合

<bean id="personlist" class="com.wengde.spring.bean.Personlist">
   <property name="name" value="ligaojing" ></property>
   <property name="age" value="30"></property>
   <property name="car" >
      <list>
        <ref bean="car"/>
        <ref bean="car2"/>
      </list>
   </property>
   </bean>

<!-- 注入List类型属性 -->
<bean id="boss" class="com.spring.model.Boss">  
    <property name="favorites">
        <list>
            <value>看报</value>
            <value>赛车</value>
            <value>高尔夫</value>
        </list>
    </propert

set集合

<bean id=”……” class=”……”>
    <property name="……">
        <set>  
            <value>value1</value>  
            <value>value2</value>  
            ……  
        </set>
    </property>
</bean> 

map集合：需要使用<map>标签来配置注入，其属性“key-type”和“value-type”分别指定“键”和“值”的数据类型。

<bean id="boss1" class="com.spring.model.Boss">  
    <property name="jobs">
        <map>
            <entry key="AM" value="会见客户" />
            <entry key="PM" value="公司内部会议" />
        </map>
    </property>
</bean> 

Properties：需要使用<props>标签来配置注入，键和值类型必须是String，不能变，子标签<prop key=”键”>值</prop>来指定键值对。

<!-- 注入Properties类型属性 -->
<bean id="boss2" class="com.spring.model.Boss">  
    <property name="mails">
        <props>
            <prop key="jobMail">john-office@163.com</prop>
            <prop key="lifeMail">john-life@163.com</prop>
        </props>
    </property>
</bean>

四 静态工厂和实例工厂的配置

静态工厂的配置

package com.wengde.spring.factory;

import java.util.HashMap;
import java.util.Map;
//静态工厂方法,在bean里应用了facotry-method，spring就不会创建当前的对象了，只调用了一个工厂方法，没有实例化对象，也就是没有调用构造方法
public class staticFactory {
    public staticFactory(){
        System.out.println(12);
    }
    private static Map<String ,Car> cars=new HashMap<String , Car>();
    static{
        cars.put("audi", new Car("audi",30000));
        cars.put("baoma", new Car("baoma",40000));
    }
    public static Car getcar(String name){
        return cars.get(name);
    }

}

配置bean

 <bean id="car1" class="com.wengde.spring.factory.staticFactory" factory-method="getcar">
     <constructor-arg value="baoma"></constructor-arg>//这个是工厂方法getcar()的参数
 </bean>

非静态工厂的配置

package com.wengde.spring.factory;

import java.util.HashMap;
import java.util.Map;

public class InstanceCar {
    private  Map<String,Car> cars=null;
    public InstanceCar(){
        System.out.println(2);
        cars=new HashMap<String, Car>();
        cars.put("audi", new Car("audi",300000));
        cars.put("baoma", new Car("baoma",400000));
        
    }
    public  Car getcar(String name){
        return cars.get(name);
    } 
}

由于是非静态的，所以必须要先有一个实例对象了才可以调用其方法

  <!-- 配置工厂的实例 -->
  <bean id="carfactory" class="com.wengde.spring.factory.InstanceCar" > </bean>
     <!-- 通过实例方法来配置bean -->
     <bean id="car2"  factory-bean="carfactory" factory-method="getcar">
     <constructor-arg value="audi"></constructor-arg>//工厂方法的参数
  </bean>

五  基于注解的方式

扫描配置：自动扫描，多个包用逗号隔开,如果某个类的头上带有特定的注解[@Component/@Repository/@Service/@Controller]，就会将这个对象作为Bean注册进Spring容器。

<context:component-scan base-package="com.wengde.spring.annotation，com...."></context:component-scan>

    <!--context： exclude-filter  排除指定资源 -->
    <!--<context:component-scan base-package="com.wengde.spring.annotation">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
    </context:component-scan>-->

1     <!--  <context:include-filter，只包含指定资源，需要use-default-filters="false"取消默认的filter，只使用指定的资源 -->
    <!-- <context:component-scan base-package="com.wengde.spring.annotation" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
    </context:component-scan>-->

   <!--assignable 按照类来  -->
   <!-- <context:component-scan base-package="com.wengde.spring.annotation" >
        <context:exclude-filter type="assignable" expression="com.wengde.spring.annotation.repository.UseRepository"/>
    </context:component-scan> -->

在类的头上带有这些注解@Component/@Repository/@Service/@Controller时，可以通过类名首字母小写的类名要获取IOC对象

package com.wengde.spring.annotation.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import com.wengde.spring.annotation.service.UserService;
@Controller
public class UserController {
    private UserService userService;
    @Autowired
      public void setUserService(UserService userService) {
        this.userService = userService;
      }
    public void execute(){
        System.out.println("UserController execute");
        userService.add();
    }
}

获取bean对象

ApplicationContext api=new ClassPathXmlApplicationContext("beans-annotations.xml");
UserController  userController=(UserController) api.getBean("userController");类名的首字母小写
userController.execute();

类的属性自动生成实例对象，通过在属性顶部加上@Autowired(required=false)，require=false是取消自动生成实例对象

package com.wengde.spring.annotation.repository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.wengde.spring.annotation.TestObject;
@Repository
public class UserRepositoryImpl implements UseRepository{
    @Autowired(required=false)
    private TestObject testObject;
    @Override
    public void save() {
        System.out.println("UserRepository Save...");
        System.out.println(testObject);
    }

}

当一个接口有多个实现类的时候，为了指定是那个特定的实现类的对象，可以通过@Qualifier("userRepositoryImpl")注解来指定对应的实现类对象

package com.wengde.spring.annotation.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import com.wengde.spring.annotation.repository.UseRepository;
import com.wengde.spring.annotation.repository.UserRepositoryImpl;
@Service
public class UserService {
    @Autowired
    @Qualifier("userRepositoryImpl")
    private UseRepository useRepository;
   public void add(){
       System.out.println("UserService add");
       useRepository.save();
   }
}

六 spring的AOP

动态代理

package com.wengde.spring.aop;
public interface ArithmeticCalculator {
    int add(int i,int j);
    int sub(int i,int j);
    int div(int i,int j);
}

ArithmeticCalculator实现类

package com.wengde.spring.aop;

public class ArithmeticCalulatorImpl  implements ArithmeticCalculator{

    @Override
    public int add(int i, int j) {
        int reslut=i+j;
        return reslut;
    }

    @Override
    public int sub(int i, int j) {
        int reslut=i-j;
        return reslut;
    }

    @Override
    public int div(int i, int j) {
        int reslut=i/j;
        return reslut;
    }

}

代理对象

package com.wengde.spring.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class ArithmeticalCalculatorLoggingProxy {
    //要代理的对象
    private ArithmeticCalculator target;
    //通过方法返回代理的对象
    public ArithmeticalCalculatorLoggingProxy(ArithmeticCalculator target) {
        super();
        this.target = target;
    }

    //
    public ArithmeticCalculator getLoggingProxy(){
    ArithmeticCalculator proxy=null;
    //代理对象由哪一个类加载器负责加载
    ClassLoader  loader=target.getClass().getClassLoader();
    //代理对象的类型，及其中有哪些方法
    Class[] interfaces=new Class[]{ArithmeticCalculator.class};
    //当调用代理对象其中的方法时，该执行的代码
    InvocationHandler h=new InvocationHandler() {
    /*
     * proxy；正在返回的那个代理对象，一般情况下，在invoke方法中都不使用该对象
     * method：正在被调用的方法
     * args：调用方法时传入的参数
     * */    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            //System.out.println(proxy.toString());
            String  methodName=method.getName();
            //日志，前置通知
            System.out.println("The  method" +methodName+" begin with["+Arrays.asList(args)+"]");
            //执行方法
            Object result=null;
                    try {
                        //返回通知
                        result=method.invoke(target, args);
                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                        //异常通知
                    }
            //后置通知
            System.out.println("The  method" +methodName+" end with"+result);
            return result;
        }
    };
    proxy=(ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);
    return proxy;
        
    }
}

main方法

package com.wengde.spring.aop;

public class Main {
    public static void main(String[] args) {
        // ArithmeticCalculator arithmeticCalculator=new ArithmeticCalulatorImpl();
       ArithmeticCalculator target=new ArithmeticCalulatorImpl();
       ArithmeticCalculator proxy=new ArithmeticalCalculatorLoggingProxy(target).getLoggingProxy();
       System.out.println(proxy.getClass().getName());//代理
      int result= proxy.add(2, 3);
      System.out.println(result);
      int result1= proxy.sub(6, 2);
      System.out.println(result1);    
    }
}

Spring的AOP（基于注解），一些常用的术语

Aspect：切面

Advice：通知

Target：目标

Proxy：代理

Joinpoint:连接点

PointCut:切点

@Before：前置通知

@After：后置通知

@AfterReturning：返回通知

@AfterThrowing：异常通知

@Around：环绕通知

@Order：切面优先级，值越小，优先级越高

用代码要实现AOP

package com.wengde.spring.aop;

public interface ArithmeticCalculator {
    int add(int i,int j);
    int sub(int i,int j);
    int div(int i,int j);
    void delete(int i,int j);

}

package com.wengde.spring.aop;

import org.springframework.stereotype.Component;

@Component
public class ArithmeticCalulatorImpl  implements ArithmeticCalculator{

    @Override
    public int add(int i, int j) {
        int reslut=i+j;
        return reslut;
    }

    @Override
    public int sub(int i, int j) {
        int reslut=i-j;
        return reslut;
    }

    @Override
    public int div(int i, int j) {
        int reslut=i/j;
        return reslut;
    }

    @Override
    public void delete(int i, int j) {
        System.out.println(i-j);
        
    }

}

package com.wengde.spring.aop;


import java.util.Arrays;
import java.util.List;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Order(1)
public class LoggingAspect {
    /*定义一个方法，用于声明切点表达式，一般地，该方法中不在需要添如其他的代码
     * 使用@pointcut来声明切入点表达式
     * 后面的其他通知直接使用方法名来引用当前的切入点表达式
     * */
    @Pointcut("execution(* com.wengde.spring.aop.ArithmeticCalculator.*(..))")// public int com.wengde.spring.aop.ArithmeticCalculator.add(int i, int j)
    public void declareJoinPointException(){}
    //前置通知，在ioc容器中找到与注解匹配的方法就执行
    @Before("declareJoinPointException()")
    public void beforeMeyhod(JoinPoint  joinpoint){
        String methodName=joinpoint.getSignature().getName();
//        Object[] args=joinpoint.getArgs();
//        System.out.println("The  method "+methodName+" begin with"+Arrays.asList(args));
        List<Object> args=Arrays.asList(joinpoint.getArgs());
        System.out.println("The  method "+methodName+" begin with"+args);
    }
  //后置通知：在目标方法执行后执行(无论发生异常)
    //在后置通知中不能访问目标方法执行结果
    @After("declareJoinPointException()")
    public void  afterMethod(JoinPoint  joinpoint){
        String methodName=joinpoint.getSignature().getName();
        System.out.println("The  method "+methodName+" ends");
    }
    //返回通知，在方法正常执行后的通知
    @AfterReturning(value="declareJoinPointException()",returning="result")
    public void  afterReturn(JoinPoint  joinpoint,Object result){
        String methodName=joinpoint.getSignature().getName();
        System.out.println("The  method "+methodName+" ends"+result);
    }
    //异常通知，在目标方法出现异常时会执行的代码，可以访问异常对象，切可以指定指定异常时在执行通知代码
    @AfterThrowing(value="declareJoinPointException()",throwing="e")
    //可以访问异常对象，切可以指定指定异常时在执行通知代码
    //public void  afterThrowing(JoinPoint  joinpoint,NULLPointException e){}
    public void  afterThrowing(JoinPoint  joinpoint,Exception e){
        String methodName=joinpoint.getSignature().getName();
        System.out.println("The  method "+methodName+" occurs"+e);
    }
    /*
     * h环绕通知需要携带ProceedingJoinPoint类型的参数
     * 环绕通知类似于动态代理的全过程，ProceedingJoinPoint类型的参数可以决定地否执行目标方法
     * 且环绕通知必须有返回值，返回值即为目标方法的返回值
     * 
     * */
//    @Around("execution(* com.wengde.spring.aop.ArithmeticCalculator.*(int , int ))")
//    public Object  aroundMethod(ProceedingJoinPoint pjd){
//        Object result=null;
//        String methodName=pjd.getSignature().getName();
//    //执行目标方法
//        try {
//            //前置通知
//            System.out.println("The method"+methodName+"begin  with"+Arrays.asList(pjd.getArgs()));
//            result= pjd.proceed();
//            //返回通知(方法正常执行后的通知)
//            
//            System.out.println("The method"+methodName+"end"+result);
//        } catch (Throwable e) {
//            //异常通知(方法出现异常出现的代码)
//            System.out.println("The  method"+methodName+"occurs exception"+e);
//             throw new  RuntimeException(e);
//        }
//        //后置通知
//        System.out.println("The method  ends ");
//        return result;//环绕通知一定需要的这个return代码
//    }
//    
}

package com.wengde.spring.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext  api=new ClassPathXmlApplicationContext("application.xml");
        ArithmeticCalculator arithmeticCalculator=(ArithmeticCalculator) api.getBean(ArithmeticCalculator.class);
        System.out.println(arithmeticCalculator.getClass().getName());
        int result=arithmeticCalculator.add(3, 55);
        System.out.println(result);
          result=arithmeticCalculator.div(6, 2);
        System.out.println(result);
        //arithmeticCalculator.delete(4, 2);//没有返回值就是null
        
    }

}

配置applicationContext

<?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/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        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-4.0.xsd">

    <context:component-scan base-package="com.wengde.spring.aop"></context:component-scan>
    <!-- 使Aspectj注解起作用，使注解的java类生成代理对象，例如 before -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

运行结果：

十月 06, 2018 11:16:00 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@df0c3a: startup date [Sat Oct 06 23:16:00 CST 2018]; root of context hierarchy
十月 06, 2018 11:16:00 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [application.xml]
十月 06, 2018 11:16:00 下午 org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor <init>
信息: JSR-330 'javax.inject.Inject' annotation found and supported for autowiring
com.sun.proxy.$Proxy13
The  method add begin with[3, 55]
-----[3, 55]
The  method add ends
The  method add ends58
58
The  method div begin with[6, 2]
-----[6, 2]
The  method div ends
The  method div ends3
3

基于XML的方式

package com.wengde.spring.aop.xml;
import java.util.Arrays;
import java.util.List;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

public class LoggingAspect {
    public void beforeMethod(JoinPoint  joinpoint){
        String methodName=joinpoint.getSignature().getName();
//        Object[] args=joinpoint.getArgs();
//        System.out.println("The  method "+methodName+" begin with"+Arrays.asList(args));
        List<Object> args=Arrays.asList(joinpoint.getArgs());
        System.out.println("The  method "+methodName+" begin with"+args);
    }
    public void  afterMethod(JoinPoint  joinpoint){
        String methodName=joinpoint.getSignature().getName();
        System.out.println("The  method "+methodName+" ends");
    }
    public void  afterReturn(JoinPoint  joinpoint,Object result){
        String methodName=joinpoint.getSignature().getName();
        System.out.println("The  method "+methodName+" ends"+result);
    }

    public void  afterThrowing(JoinPoint  joinpoint,Exception e){
        String methodName=joinpoint.getSignature().getName();
        System.out.println("The  method "+methodName+" occurs"+e);
    }

//    public Object  aroundMethod(ProceedingJoinPoint pjd){
//        Object result=null;
//        String methodName=pjd.getSignature().getName();
//    //执行目标方法
//        try {
//            //前置通知
//            System.out.println("The method"+methodName+"begin  with"+Arrays.asList(pjd.getArgs()));
//            result= pjd.proceed();
//            //返回通知(方法正常执行后的通知)
//            
//            System.out.println("The method"+methodName+"end"+result);
//        } catch (Throwable e) {
//            //异常通知(方法出现异常出现的代码)
//            System.out.println("The  method"+methodName+"occurs exception"+e);
//             throw new  RuntimeException(e);
//        }
//        //后置通知
//        System.out.println("The method  ends ");
//        return result;//环绕通知一定需要的这个return代码
//    }
//    
}

配置applicationContext

<?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/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        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-4.0.xsd">

    <bean id="arithmeticCalculator" class="com.wengde.spring.aop.xml.ArithmeticCalulatorImpl"></bean>
    <!-- 配置切面的bean -->
    <bean id="loggingAspect" class="com.wengde.spring.aop.xml.LoggingAspect"></bean>
    <bean id="vlidation" class="com.wengde.spring.aop.xml.Vlidation"></bean>
    <!-- 配置aop配置 -->
    <aop:config>
        <!-- 配置切点表达式 -->
        <aop:pointcut expression="execution(*  com.wengde.spring.aop.xml.ArithmeticCalculator.*(int , int))" id="pointcut"/>
        <!-- 配置切面以及通知 -->
        <aop:aspect ref="loggingAspect" order="2">
           <aop:before method="beforeMethod" pointcut-ref="pointcut"/>
           <aop:after-returning method="afterReturn" pointcut-ref="pointcut" returning="result"/>
           <aop:after method="afterMethod" pointcut-ref="pointcut"/>
           <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/>
        </aop:aspect>
        <aop:aspect ref="vlidation" order="1">
          <aop:before method="vlidation" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

JdbcTemplate查询数据库以及事务

配置

<?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/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
 <context:component-scan base-package="com.wengde.spring"></context:component-scan>
 
 <!-- 导入资源文件 -->
  <context:property-placeholder location="classpath:db.properties"/>
  <!-- 配置 C3p0数据源-->
  <bean id="dataSourse" class="com.mchange.v2.c3p0.ComboPooledDataSource">
     <property name="user" value="${user}"></property>
     <property name="password" value="${password}"></property>
     <property name="driverClass" value="${driverClass}"></property>
     <property name="jdbcUrl" value="${url}"></property>
     <property name="initialPoolSize" value="${initPoolSize}"></property>
     <property name="maxPoolSize" value="${maxPoolSize}"></property>
  </bean>
    <!-- 配置spring的jdbc -->
    <bean  id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
      <property name="dataSource" ref="dataSourse"></property>
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource" ref="dataSourse"></property>
    
    </bean>
    <!-- 启动事务管理器 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

test类

package com.wengde.spring.jdbc;

import static org.junit.Assert.*;

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

import javax.sql.DataSource;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;


public class JDBCtest {
   private ApplicationContext api=null;
   private JdbcTemplate jdbcTemplate;
   {
       api=new ClassPathXmlApplicationContext("applicationContext.xml");
       jdbcTemplate=(JdbcTemplate) api.getBean("jdbcTemplate");
       
   }
    @Test
    public void testDataSourse() throws SQLException {
        DataSource dataSource=(DataSource) api.getBean("dataSourse");
        System.out.println(dataSource.getConnection());
    }
    /*执行insert,update,delete 
     * 
     * 
     */
    @Test
    public void testUpdate(){
        String sql="update mybooks set Title=? where id=?";
        jdbcTemplate.update(sql, "java",1);
    }
    /*执行批量更新，批量insert，批量update，批量delete
     * 
     * */
    @Test
  public void testBathUpdate(){
      String  sql="insert into mybooks(author,title,price,Publishingdate,Salesamount,Storenumber,Remark) values(?,?,?,?,?,?,?)";
      List<Object[]> batchArgs=new ArrayList<Object[]>();
      batchArgs.add(new Object[]{"zhang","AA","120","2018-10-5","55","66","加油"});
      batchArgs.add(new Object[]{"li","BB","130","2018-10-4","77","88","努力"});
      jdbcTemplate.batchUpdate(sql, batchArgs);
      
  }
     /* 获取一个对象
      * 注意不是调用queryForObject(String sql, Class<Book> requiredType, Object... args) 方法,该方法是获取某一个字段的值
      * 而需要调用queryForObject(String sql, RowMapper<Book> rowMapper, Object... args) 
      * 1.其中的rowMapper指定如何去映射结果集的行，常用的实现类是BeanPropertyRowMapper
      * 
      * */ 
    @Test
  public void testQueryObject(){
      String  sql ="select * from mybooks where id=?";
    // Book  book= jdbcTemplate.queryForObject(sql, Book.class, 1);
      RowMapper<Book> rowMapper=new BeanPropertyRowMapper<Book>(Book.class);
      Book book=jdbcTemplate.queryForObject(sql, rowMapper, 1);
     System.out.println(book);
  
      }
    /*查询实体类的集合
     * 注意  调用的不是queryForlist()方法
     * 
     * 
     * */
    @Test
    public void testQueryForlist(){
        String  sql ="select * from mybooks where id<?";
         RowMapper<Book> rowMapper=new BeanPropertyRowMapper<Book>(Book.class);
        List<Book> books=jdbcTemplate.query(sql, rowMapper,5);
        System.out.println(books);
        
    }
    /*
     * 查询单列的值或者统计查询
     * queryForObject(String sql, Class<Long> requiredType)
     * */
    @Test
    public void testQueryForObject(){
        String sql="select count(id) from mybooks";
        long count=jdbcTemplate.queryForObject(sql, Long.class);
        System.out.println(count);
    }
}

 基于xml文件的事务配置

<?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/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

 
 <!-- 导入资源文件 -->
  <context:property-placeholder location="classpath:db.properties"/>
  <!-- 配置 C3p0数据源-->
  <bean id="dataSourse" class="com.mchange.v2.c3p0.ComboPooledDataSource">
     <property name="user" value="${user}"></property>
     <property name="password" value="${password}"></property>
     <property name="driverClass" value="${driverClass}"></property>
     <property name="jdbcUrl" value="${url}"></property>
     <property name="initialPoolSize" value="${initPoolSize}"></property>
     <property name="maxPoolSize" value="${maxPoolSize}"></property>
  </bean>
  <!-- 配置Spring的Jdbctemplate -->
  <bean  id="jdbcTemplate"  class="org.springframework.jdbc.core.JdbcTemplate">
     <property name="dataSource" ref="dataSourse"></property>
  </bean>
  <!-- 配置bean -->
   <bean id="bookStockDao" class="com.wengde.spring.tx.xml.BookStockDaoImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate"></property>
   </bean>
    <bean id="bookShopServic" class="com.wengde.spring.tx.xml.service.impl.BookShopServiceImpl">
     <property name="bookShopDao" ref="bookStockDao"></property>
     </bean>
     <bean id="cashier" class="com.wengde.spring.tx.xml.service.impl.CashierImpl">
      <property name="bookShopService" ref="bookShopServic"></property>
     </bean>
     
     <!-- 配置事务管理器 -->
     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
       <property name="dataSource" ref="dataSourse"></property>
     </bean>
     <!-- 配置事务属性 -->
     <tx:advice id="txadvice" transaction-manager="transactionManager">
        <tx:attributes>
          <!-- 根据方法名指定事务的属性 -->
          <tx:method name="purchase" propagation="REQUIRES_NEW"/>
          <tx:method name="*"/>
        </tx:attributes>
     </tx:advice>
     <!-- 配置事务切入点，以及把事务切入点和事务属性关联起来 -->
     <aop:config>
       <aop:pointcut expression="execution(* com.wengde.spring.tx.xml.service.*.*(..) )" id="txPointCut"/>
       <aop:advisor advice-ref="txadvice" pointcut-ref="txPointCut"/>
     </aop:config>
</beans>