spring入门(AOP)

AOP

简介

什么是AOP

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码
经典应用：事务管理、性能监视、安全检查、缓存、日志等
Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码
AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入

AOP实现原理

aop底层将采用代理机制进行实现。
接口 + 实现类：spring采用 jdk 的动态代理Proxy。
实现类：spring 采用 cglib字节码增强。

AOP术语

target：目标类，需要被代理的类。例如：UserService
Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法
PointCut 切入点：已经被增强的连接点。例如：addUser()
advice 通知/增强，增强代码。例如：after、before
Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
proxy 代理类
Aspect(切面): 是切入点pointcut和通知advice的结合
一个线是一个特殊的面。
一个切入点和一个通知，组成成一个特殊的面。

手动方法

jdk的动态代理

JDK动态代理对“装饰者”设计模式简化。使用前提：必须有接口
动态代理过程

目标类：接口 + 实现类
切面类：用于存通知 MyAspect
工厂类：编写工厂生成代理
测试

创建目标接口和类

public interface UserService {
    public void addUser();
    public void updateUser();
    public void deleteUser();
}
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("addUser");
    }
    @Override
    public void updateUser() {
        System.out.println("updateUser");
    }
    @Override
    public void deleteUser() {
        System.out.println("deleteUser");
    }
}

创建切面类

public class MyAspect {
    public void before(){
        System.out.println("之前");
    }

    public void after(){
        System.out.println("之后");
    }
}

创建工厂类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MyBeanFactory {
    public static UserService createService(){
        //1 目标类
        final UserService userService = new UserServiceImpl();
        //2切面类
        final MyAspect myAspect = new MyAspect();
        /* 3 代理类：将目标类（切入点）和 切面类（通知） 结合 --> 切面
         *  Proxy.newProxyInstance
         *      参数1：loader ，类加载器，动态代理类 运行时创建，任何类都需要类加载器将其加载到内存。
         *          一般情况：当前类.class.getClassLoader();
         *                  目标类实例.getClass().get...
         *      参数2：Class[] interfaces 代理类需要实现的所有接口
         *          方式1：目标类实例.getClass().getInterfaces()  ;注意：只能获得自己接口，不能获得父元素接口
         *          方式2：new Class[]{UserService.class}
         *          例如：jdbc 驱动  --> DriverManager  获得接口 Connection
         *      参数3：InvocationHandler  处理类，接口，必须进行实现类，一般采用匿名内部
         *          提供 invoke 方法，代理类的每一个方法执行时，都将调用一次invoke
         *              参数31：Object proxy ：代理对象
         *              参数32：Method method : 代理对象当前执行的方法的描述对象（反射）
         *                  执行方法名：method.getName()
         *                  执行方法：method.invoke(对象，实际参数)
         *              参数33：Object[] args :方法实际参数
         *
         */
        UserService proxService = (UserService)Proxy.newProxyInstance(
                                MyBeanFactory.class.getClassLoader(),
                                userService.getClass().getInterfaces(),
                                new InvocationHandler() {

                                    @Override
                                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                                        //前执行
                                        myAspect.before();
                                        //执行目标类的方法
                                        Object obj = method.invoke(userService, args);
                                        //后执行
                                        myAspect.after();
                                        return obj;
                                    }
                                });

        return proxService;
    }
}

测试

UserService userService = MyBeanFactory.createService();
userService.addUser();
userService.updateUser();
userService.deleteUser();

执行结果:
之前
addUser
之后
之前
updateUser
之后
之前
deleteUser
之后

CGLIB字节码增强

没有接口，只有实现类。
采用字节码增强框架 cglib，在运行时创建目标类的子类，从而对目标类进行增强。
导入jar包：
自己导包（了解）：
核心：hibernate-distribution-3.6.10.Final\lib\bytecode\cglib\cglib-2.2.jar
依赖：struts-2.3.15.3\apps\struts2-blank\WEB-INF\lib\asm-3.3.jar
spring-core..jar 已经整合以上两个内容

代码和上面一样，不过没有接口
工厂类:

public class MyBeanFactory {
    public static UserServiceImpl createService(){
        //1 目标类
        final UserServiceImpl userServiceImpl = new UserServiceImpl();
        //2切面类
        final MyAspect myAspect = new MyAspect();
        // 3.代理类 ，采用cglib，底层创建目标类的子类
        //3.1 核心类
        Enhancer enhancer = new Enhancer();
        //3.2 确定父类
        enhancer.setSuperclass(userServiceImpl.getClass());
        /* 3.3 设置回调函数 , MethodInterceptor接口 等效 jdk InvocationHandler接口
         *  intercept() 等效 jdk  invoke()
         *      参数1、参数2、参数3：以invoke一样
         *      参数4：methodProxy 方法的代理
         *
         *
         */
        enhancer.setCallback(new MethodInterceptor(){
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

                //前
                myAspect.before();

                //执行目标类的方法
                Object obj = method.invoke(userServiceImpl, args);
                // * 执行代理类的父类 ，执行目标类 （目标类和代理类 父子关系）和上面一样功能，只是两种形式
                methodProxy.invokeSuper(proxy, args);
                //后
                myAspect.after();

                return obj;
            }
        });
        //3.4 创建代理
        UserServiceImpl proxService = (UserServiceImpl) enhancer.create();
        return proxService;
    }
}

这段代码每个方法会执行两遍，因为上面invoke和invokeSuper都是执行方法，用的时候只用执行一个就行

AOP联盟通知类型

AOP联盟为通知Advice定义了org.aopalliance.aop.Advice
Spring按照通知Advice在目标类方法的连接点位置，可以分为5类

前置通知 org.springframework.aop.MethodBeforeAdvice：在目标方法执行前实施增强
后置通知 org.springframework.aop.AfterReturningAdvice：在目标方法执行后实施增强
环绕通知 org.aopalliance.intercept.MethodInterceptor：在目标方法执行前后实施增强
异常抛出通知 org.springframework.aop.ThrowsAdvice：在方法抛出异常后实施增强
引介通知 org.springframework.aop.IntroductionInterceptor：在目标类中添加一些新的方法和属性

重点掌握环绕通知，必须手动执行目标方法

try{
   //前置通知
   //执行目标方法
   //后置通知
} catch(){
   //抛出异常通知
}

spring编写代理:半自动

让spring 创建代理对象，从spring容器中手动的获取代理对象。
导入jar包：
核心：4+1
AOP：AOP联盟（规范）下载地址
spring-aop（实现）(jar包在spring的framework中spring-aop-5.1.3.RELEASE.jar)

代码示例

接口+实现类:

public interface UserService {
    public void addUser();
    public void updateUser();
    public void deleteUser();
}
public class UserServiceImpl implements UserService{

    public void addUser() {
        System.out.println("addUser");
    }

    public void updateUser() {
        System.out.println("updateUser");
    }

    public void deleteUser() {
        System.out.println("deleteUser");
    }

}

切面类

public class MyAspect implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        System.out.println("前");
        //手动执行目标方法
        Object obj = mi.proceed();
        System.out.println("后");
        return obj;

    }
}

配置文件

<!-- 1 创建目标类 -->
<bean id="userServiceId" class="cn.xwmdream.springMain.UserServiceImpl"></bean>
<!-- 2 创建切面类 -->
<bean id="myAspectId" class="cn.xwmdream.springMain.MyAspect"></bean>
<!-- 3 创建代理类
    * 使用工厂bean FactoryBean ，底层调用 getObject() 返回特殊bean
    * ProxyFactoryBean 用于创建代理工厂bean，生成特殊代理对象
        interfaces : 确定接口们
            通过<array>可以设置多个值:<property name="interfaces"><array><value></value></array></property>
            只有一个值时，value=""
        target : 确定目标类
        interceptorNames : 通知 切面类的名称，类型String[]，如果设置一个值 value=""
        optimize :强制使用cglib
            <property name="optimize" value="true"></property>
    底层机制
        如果目标类有接口，采用jdk动态代理
        如果没有接口，采用cglib 字节码增强
        如果声明 optimize = true ，无论是否有接口，都采用cglib
-->
<bean id="proxyServiceId" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="interfaces" value="cn.xwmdream.springMain.UserService"></property>
    <property name="target" ref="userServiceId"></property>
    <property name="interceptorNames" value="myAspectId"></property>
</bean>

测试

String xmlPath = "applicationContext.xml";
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
//获得代理类
UserService userService = (UserService) applicationContext.getBean("proxyServiceId");
userService.addUser();
userService.updateUser();
userService.deleteUser();

运行结果:
前
addUser
后
前
updateUser
后
前
deleteUser
后

全自动

从spring容器获得目标类，如果配置aop，spring将自动生成代理。
要确定目标类，aspectj 切入点表达式，导入jar包下载地址

代码

实现类和切面类还是上面，变化的是配置文件

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 1 创建目标类 -->
    <bean id="userServiceId" class="cn.xwmdream.springMain.UserServiceImpl"></bean>
    <!-- 2 创建切面类（通知） -->
    <bean id="myAspectId" class="cn.xwmdream.springMain.MyAspect"></bean>
    <!-- 3 aop编程
        3.1 导入命名空间
        3.2 使用 <aop:config>进行配置
                proxy-target-class="true" 声明时使用cglib代理
            <aop:pointcut> 切入点 ，从目标对象获得具体方法
            <aop:advisor> 特殊的切面，只有一个通知 和 一个切入点
                advice-ref 通知引用
                pointcut-ref 切入点引用
        3.3 切入点表达式
            execution(* com.itheima.c_spring_aop.*.*(..))
            选择方法  返回值任意   包  类名任意  方法名任意   参数任意
    -->
    <aop:config proxy-target-class="true">
        <aop:pointcut expression="execution(* cn.xwmdream.springMain.*.*(..))" id="myPointCut"/>
        <aop:advisor advice-ref="myAspectId" pointcut-ref="myPointCut"/>
    </aop:config>
</beans>

注意配置aop命名空间
切入点表示要代理的方法，就是上面的myPointCut的那个表达式

测试

String xmlPath = "applicationContext.xml";
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
//获得代理类
UserServiceImpl userService = (UserServiceImpl) applicationContext.getBean("userServiceId");
userService.addUser();
userService.updateUser();
userService.deleteUser();

因为使用了cglib所以能直接获得实现类

AspectJ

介绍

AspectJ是一个基于Java语言的AOP框架
Spring2.0以后新增了对AspectJ切点表达式支持
@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面
新版本Spring框架，建议使用AspectJ方式来开发AOP
主要用途：自定义开发

导入jar包

4个：

aop联盟规范
spring aop 实现
aspect 规范下载地址
spring aspect 实现(框架中)(spring-aspects-5.1.3.RELEASE.jar)

切入点表达式

execution() 用于描述方法【掌握】
语法：execution(修饰符返回值包.类.方法名(参数) throws异常)

修饰符，一般省略
public 公共方法
- 任意
返回值，不能省略
void 返回没有值
String 返回值字符串
- 任意
包，[省略]
cn.xwmdream.crm 固定包
cn.xwmdream.crm..service crm包下面子包任意（例如：cn.xwmdream.crm.staff.service）
cn.xwmdream.crm.. crm包下面的所有子包（含自己）
cn.xwmdream.crm..service.. crm包下面任意子包，固定目录service，service目录任意包
类，[省略]
UserServiceImpl 指定类
Impl 以Impl结尾
User 以User开头
- 任意
方法名，不能省略
addUser 固定方法
add 以add开头 Do 以Do结尾
- 任意
(参数)
() 无参
(int) 一个整型
(int ,int) 两个
(..) 参数任意
throws ,可省略，一般不写。
综合1
execution( com.itheima.crm..service...(..))
综合2
<aop:pointcut expression=”execution( com.itheima.WithCommit.*(..)) ||
```
execution(* com.itheima.*Service.*(..))" id="myPointCut"/>
```

within:匹配包或子包中的方法(了解)
within(com.itheima.aop..*)
this:匹配实现接口的代理对象中的方法(了解)
this(com.itheima.aop.user.UserDAO)
target:匹配实现接口的目标对象中的方法(了解)
target(com.itheima.aop.user.UserDAO)
args:匹配参数格式符合标准的方法(了解)
args(int,int)
bean(id) 对指定的bean所有的方法(了解)
bean(‘userServiceId’)
更多用法

AspectJ 通知类型

aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称。
aspectj 通知类型，只定义类型名称。已经方法格式。
个数：6种，知道5种，掌握1中。

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

重点学习环绕通知

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

基于xml

目标类：接口 + 实现
切面类：编写多个通知，采用aspectj 通知名称任意（方法名任意）
aop编程，将通知应用到目标类
测试
目标类+接口，还是上面的UserService和UserServiceImpl

切面类

public class MyAspect {
    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);
    }
    //返回值必须是object
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("前");
        //手动执行目标方法
        Object obj = joinPoint.proceed();

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

配置xml

<!-- 1 创建目标类 -->
<bean id="userServiceId" class="cn.xwmdream.springMain.UserServiceImpl"></bean>
<!-- 2 创建切面类（通知） -->
<bean id="myAspectId" class="cn.xwmdream.springMain.MyAspect"></bean>
<!-- 3 aop编程
    <aop:aspect> 将切面类 声明“切面”，从而获得通知（方法）
        ref 切面类引用
    <aop:pointcut> 声明一个切入点，所有的通知都可以使用。
        expression 切入点表达式
        id 名称，用于其它通知引用
-->
<aop:config>
    <aop:aspect ref="myAspectId">
        <aop:pointcut expression="execution(* cn.xwmdream.springMain.UserServiceImpl.*(..))" id="myPointCut"/>

        <!-- 3.1 前置通知
            <aop:before method="" pointcut="" pointcut-ref=""/>
                method : 通知，及方法名
                pointcut :切入点表达式，此表达式只能当前通知使用。
                pointcut-ref ： 切入点引用，可以与其他通知共享切入点。
            通知方法格式：public void myBefore(JoinPoint joinPoint){
                参数1：org.aspectj.lang.JoinPoint  用于描述连接点（目标方法），获得目标方法名等
            例如：
        <aop:before method="myBefore" pointcut-ref="myPointCut"/>
        -->

        <!-- 3.2后置通知  ,目标方法后执行，获得返回值
            <aop:after-returning method="" pointcut-ref="" returning=""/>
                returning 通知方法第二个参数的名称
            通知方法格式：public void myAfterReturning(JoinPoint joinPoint,Object ret){
                参数1：连接点描述
                参数2：类型Object，参数名 returning="ret" 配置的
            例如：
        <aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />
        -->

        <!-- 3.3 环绕通知
            <aop:around method="" pointcut-ref=""/>
            通知方法格式：public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
                返回值类型：Object
                方法名：任意
                参数：org.aspectj.lang.ProceedingJoinPoint
                抛出异常
            执行目标方法：Object obj = joinPoint.proceed();
            例如：
        <aop:around method="myAround" pointcut-ref="myPointCut"/>
        -->
        <!-- 3.4 抛出异常
            <aop:after-throwing method="" pointcut-ref="" throwing=""/>
                throwing ：通知方法的第二个参数名称
            通知方法格式：public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
                参数1：连接点描述对象
                参数2：获得异常信息，类型Throwable ，参数名由throwing="e" 配置
            例如：
        <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
        -->
        <!-- 3.5 最终通知 -->
        <aop:after method="myAfter" pointcut-ref="myPointCut"/>
    </aop:aspect>
</aop:config>

测试

String xmlPath = "applicationContext.xml";
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
//获得代理类
UserService userService = (UserService) applicationContext.getBean("userServiceId");
userService.addUser();
userService.updateUser();
userService.deleteUser();

如果是抛出异常的方法，比如updateUser抛出异常，那么deleteUser不会执行
最终通知，只要切入点执行了，那么最终通知肯定会执行

如果一个通知私有，表示这个myBefore单独给这个表达式加通知

1	<aop:before method="myBefore" pointcut="execution(* cn.xwmdream.springMain.UserServiceImpl.*(..))"/>

基于注解

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd
                            http://www.springframework.org/schema/jdbc
                            http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
                            http://www.springframework.org/schema/context
                            http://www.springframework.org/schema/context/spring-context-4.3.xsd">
    <!-- 1.扫描 注解类 -->
    <context:component-scan base-package="cn.xwmdream.springMain"></context:component-scan>
    <!-- 2.确定 aop注解生效 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

目标类

@Service("userServiceImplId")
public class UserServiceImpl implements UserService{
    public void addUser() {
        System.out.println("addUser");
    }
    public void updateUser() {
        System.out.println("updateUser");
    }
    public void deleteUser() {
        System.out.println("deleteUser");
    }
}
public interface UserService {
    public void addUser();
    public void updateUser();
    public void deleteUser();
}

切面类

//先声明是一个bean，再声明是一个aspect
@Component
@Aspect
public class MyAspect {
    //注解前置通知
    //@Before("execution(* cn.xwmdream.springMain.UserServiceImpl.*(..))")
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    }

    //也可以声明公共切入点
    @Pointcut("execution(* cn.xwmdream.springMain.UserServiceImpl.*(..))")
    private void myPointCut() {

    }
    //@AfterReturning(value="myPointCut()" ,returning="ret")
    public void myAfterReturning(JoinPoint joinPoint,Object ret){
        System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    }
    //返回值必须是object
    //@Around(value = "myPointCut()")
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("前");
        //手动执行目标方法
        Object obj = joinPoint.proceed();

        System.out.println("后");
        return obj;
    }
    //@AfterThrowing(value="myPointCut()" ,throwing="e")
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("抛出异常通知 ： " + e.getMessage());
    }
    //@After(value="myPointCut()")
    public void myAfter(JoinPoint joinPoint){
        System.out.println("最终通知");
    }
}

运行

String xmlPath = "applicationContext.xml";
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
//获得代理类
UserService userService = (UserService) applicationContext.getBean("userServiceImplId");
userService.addUser();
userService.updateUser();
userService.deleteUser();

aop注解总结

@Aspect 声明切面，修饰切面类，从而获得通知。
通知
@Before 前置
@AfterReturning 后置
@Around 环绕
@AfterThrowing 抛出异常
@After 最终
切入点
@PointCut ，修饰方法 private void xxx(){} 之后通过“方法名”获得切入点引用

JdbcTemplate

spring 提供用于操作JDBC工具类，类似：DBUtils。
依赖连接池DataSource （数据源）

环境搭建

创建数据表

create database my_database;
use my_database;
create table t_user(
  id int primary key auto_increment,
  username varchar(50),
  password varchar(32)
);

insert into t_user(username,password) values('jack','1234');
insert into t_user(username,password) values('rose','5678');

导入jar包

这里的jar
spring-jdbc-5.1.3.RELEASE.jar(spring-framework中)
spring-tx-5.1.3.RELEASE.jar(spring-framework中)
commons-dbcp2-2.5.0.jar下载地址
commons-pool2-2.6.0.jar下载地址
tomcat的lib下还要有tomcat-juli.jar

javabean

public class User {
    private Integer id;
    private String username;
    private String password;
   /*
   get&set
   */
}

1.使用api方式(不常用，因为没使用spring)

//1 创建数据源（连接池） dbcp
BasicDataSource dataSource = new BasicDataSource();
// * 基本4项
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/my_database");
dataSource.setUsername("root");
dataSource.setPassword("6");
//2  创建模板
JdbcTemplate jdbcTemplate = new JdbcTemplate();
jdbcTemplate.setDataSource(dataSource);
//3 通过api操作
jdbcTemplate.update("insert into t_user(username,password) values(?,?);", "tom","998");

2.配置dbcp

创建UserDao,提供一个update

public class UserDao{
    //jdbc模板将有spring注入
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    public void updata(User user) {
        String sql = "update t_user set username=?,password=? where id=?";
        Object[] args = {user.getUsername(),user.getPassword(),user.getId()};
        jdbcTemplate.update(sql,args);
    }
}

写配置文件

<!-- 创建数据源 -->
<bean id="dataSourceId" class="org.apache.tomcat.dbcp.dbcp2.BasicDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/my_database"></property>
    <property name="username" value="root"></property>
    <property name="password" value="xxx"></property>
</bean>
<!-- 创建模板 ,需要注入数据源-->
<bean id="jdbcTemplateId" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSourceId"></property>
</bean>

<!-- 配置dao -->
<bean id="userDaoId" class="cn.xwmdream.springMain.UserDao">
    <property name="jdbcTemplate" ref="jdbcTemplateId"></property>
</bean>

注意他们的包名类名，如果不知道可以用第一种方法看看具体报名
用di注入了他们的参数

调用

User user = new User();
user.setId(1);
user.setUsername("name");
user.setPassword("123");
String xmlPath = "applicationContext.xml";
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
//获得代理类
UserDao userdao = (UserDao) applicationContext.getBean("userDaoId");
userdao.updata(user);

3.使用c3p0

只需要把数据源从BasicDataSource改成c3p0

<!-- 创建数据源 -->
<bean id="dataSourceId" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/my_database"></property>
    <property name="user" value="root"></property>
    <property name="password" value="xxx"></property>
</bean>

4.使用JdbcDaoSupport

JdbcDaoSupport内置了JdbcTemplate，所以就不用自己写JdbcTemplate
配置文件中只用配置dao和数据源

配置文件

<!-- 创建数据源 -->
<bean id="dataSourceId" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/my_database"></property>
    <property name="user" value="root"></property>
    <property name="password" value="x"></property>
</bean>
<!-- 配置dao -->
<bean id="userDaoId" class="cn.xwmdream.springMain.UserDao">
    <property name="dataSource" ref="dataSourceId"></property>
</bean>

父类实现了dataSource的注入

Dao

public class UserDao extends JdbcDaoSupport{
    public void updata(User user) {
        String sql = "update t_user set username=?,password=? where id=?";
        Object[] args = {user.getUsername(),user.getPassword(),user.getId()};
        this.getJdbcTemplate().update(sql,args);
    }
}

直接用this.getJdbcTemplate()就能调用到模板进行相应操作

使用properties写入配置

创建一个properties

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/my_database
jdbc.user=root
jdbc.password=xxx

配置文件

<!-- 加载配置文件
    "classpath:"前缀表示 src下如果要写目录就是cn/xxx/xxx.properties
    在配置文件之后通过  ${key} 获得内容
-->
<context:property-placeholder location="classpath:jdbcInfo.properties"/>

<!-- 创建数据源 c3p0-->
<bean id="dataSourceId" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driverClass}"></property>
    <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
    <property name="user" value="${jdbc.user}"></property>
    <property name="password"  value="${jdbc.password}"></property>
</bean>