Spring学习笔记(二)

时间 2019-11-11

标签 spring 学习笔记栏目 Spring 繁體版

原文原文链接

Spring学习笔记(二)

这是一个沉淀的过程，大概第一次接触Spring是在去年的这个时候，当初在实训，初次接触Java web，直接学习SSM框架（当是Servlet都没有学），因而，养成了一个很很差的学习习惯，就是“照猫画虎”。别人作什么，照着样子就是了，没有任何的思考，这样的学习习惯确定不会走太远。如今我产生不少疑惑，这是什么？为何这么作？如何作的更好？所以此次笔记的主题就是《这是什么？》java

1. AOP

1.1 AOP介绍

1.1.1 什么是AOP

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

1.1.2 AOP 实现原理

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

1.1.2 AOP 术语

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

1.2 手动方式

1.2.1 JDK 动态代理

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

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

1.2.1.1 目标类

public interface UserService {

    void addUser();
    void updateUser();
    void deleteUser();
}

1.2.1.2 切面类

public class MyAspect {

    public void before(){
        System.out.println("this is before");
    }

    public void after(){
        System.out.println("this is after");
    }
}

1.2.1.3 工厂

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;
    }
    }
}

1.2.1.4 测试类

@Test
    public void demo01(){
        UserService userService = MyBeanFactory.createService();
        userService.addUser();
        userService.updateUser();
        userService.deleteUser();
    }

1.2.2 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 已经整合以上两个内容

1.2.2.1 工厂类

public class MyBeanFactory {

    public static UserService createService(){
        //1 目标类
        final UserService userService = new UserServiceImpl();
        //2 切面类
        final MyAspect myAspect = new MyAspect();
        // 3.代理类 ，采用cglib ,底层建立目标类的子类
        // 3.1 核心类
        Enhancer enhancer = new Enhancer();
        // 3.2 肯定父类
        enhancer.setSuperclass(userService.getClass());

        /**
         * 3.3 设置回调函数 ， MethodInterceptor接口 等效 jdk InvocationHander接口
         *      intercept() 等效 jdk  invoke()
         *          参数一、参数二、参数3：以invoke同样
         *          参数4：methodProxy 方法的代理
         */

        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                //前执行
                myAspect.before();

                //执行目标类方法
                Object obj = method.invoke(userService,objects);
                // * 执行代理类的父类，执行目标类（目标类和代理类 父子关系）
             //   methodProxy.invokeSuper(o,objects);

                //后执行
                myAspect.after();
                return obj;
            }
        });
        //3.4 建立代理
        UserServiceImpl proxService = (UserServiceImpl) enhancer.create();

        return proxService;
    }
}

1.3 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(){
 //抛出异常通知
}
```
  1.4 spring 编写代理：半自动
让spring 建立代理对象，从spring容器中手动的获取代理对象。
导入jar包：
核心：4+1
AOP：AOP联盟（规范）、spring-aop （实现）

1.4.1 目标类

public interface UserService {

    void addUser();
    void updateUser();
    void deleteUser();
}

1.4.2 切面类

/**
 *  切面类中肯定通知，须要实现不一样接口，接口就是规范，从而就肯定方法名称。
 *  采用“环绕通知” MethodInterceptor
 */
public class MyAspect implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("this is before");

        //手动执行目标方法
        Object obj = methodInvocation.proceed();

        System.out.println("this is after");
        return obj;
    }
}

1.4.3 spring 配置

<!-- 1 建立目标类-->
    <bean id="userService" class="com.springlearning.spring_proxy.UserServiceImpl"></bean>
    <!-- 2 建立切面类-->
    <bean id="myAspect" class="com.springlearning.spring_proxy.MyAspect"></bean>

    <!-- 3 建立代理类
         * 使用工厂bean FactoryBean ,底层调用getObject() 返回特殊bean
         * ProxyFactoryBean 用于建立代理工厂bean ,生成特殊代理对象
                interfaces : 肯定接口们
                    经过<array> 能够设置多个值
                    只有一个值时， value=""
                target : 肯定目标类
                interceptorNames : 通知 切面类的名称，类型String[], 若是设置一个值 value=""
                optimize :强制使用cglib
                    <property name="optimize" value="true"></property>
          底层机制
                若是目标类有接口，采用jdk动态代理
                若是没有接口，采用cglib 字节码加强
                若是声明 optimize = true ,不管是否有接口 ，都采用cglib
    -->
    <bean id="proxyService" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces" value="com.springlearning.spring_proxy.UserService"></property>
        <property name="target" ref="userService"></property>
        <property name="interceptorNames" value="myAspect"></property>
    </bean>

1.4.4 测试

@Test
    public void demo01(){
        String xmlPath = "com/springlearning/spring_proxy/beans.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        //得到代理类
        UserService userService = (UserService) applicationContext.getBean("proxyService");
        userService.addUser();
        userService.updateUser();
        userService.deleteUser();
    }

1.5 spring aop 编程：全自动

从spring容器得到目标类，若是配置aop，spring将自动生成代理。
要肯定目标类，aspectj 切入点表达式，导入jar包
在spring-aop-5.0.4版本中包含了aopalliance和aspectj
数据库
这里我在调试的时候出了问题，其中在spring-aop-5.0.4版本中包含了aopalliance,而我看的教学是3.x的版本,须要导入另外的aopalliance包，还有错把aspectjrt 当成 aspectjweaver,然而两个包有着不一样的功能。express

1.5.1 spring 配置

<?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="userService" class="com.springlearning.spring_proxy.UserServiceImpl"></bean>
    <!-- 2 建立切面类（通知）-->
    <bean id="myAspect" class="com.springlearning.spring_proxy.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.springlearning.spring_proxy.*.(..))
            选择方法   返回值任意  包         类名称任意  方法名任意   参数任意
    -->
    <aop:config proxy-target-class="true">
        <aop:pointcut id="myPointCut" expression="execution(* com.springlearning.spring_proxy.*.*(..))"/>
        <aop:advisor advice-ref="myAspect" pointcut-ref="myPointCut"></aop:advisor>
    </aop:config>
</beans>

1.5.2 测试

@Test
    public void demo01(){
        String xmlPath = "com/springlearning/spring_proxy/beans.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);

        //得到代理类
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.addUser();
        userService.updateUser();
        userService.deleteUser();
    }

2. AspectJ

2.1 介绍

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

2.2 切入点表达式

execution() 用于描述方法
语法：execution(修饰符返回值包.类.方法名(参数) throws异常)
修饰符，通常省略
public 公共方法
* 任意
返回值，不能省略
void 返回没有值
String 返回值字符串
* 任意
包，[省略]
com.springlearning.proxy 固定包
com.springlearning.proxy..service proxy包下面子包任意（例如：com.springlearning.proxy.staff.service）
com.springlearning.proxy.. proxy包下面的全部子包（含本身）
com.springlearning.proxy..service.. proxy包下面任意子包，固定目录service，service目录任意包
类，[省略]
UserServiceImpl 指定类
Impl 以Impl结尾
User 以User开头
* 任意
方法名，不能省略
addUser 固定方法
add* 以add开头
Do 以Do结尾
任意
(参数)
() 无参
(int) 一个整型
(int ,int) 两个
(..) 参数任意
throws ,可省略，通常不写。

综合 1
execution(* com.springlearning.proxy..service...*(..))apache

综合 2
<aop:pointcut expression="execution(* com.springlearning.WithCommit.(..)) ||
execution(* com.springlearning.Service.(..))" id="myPointCut"/>编程

within:匹配包或子包中的方法
within(com.springlearning.aop..*)
this:匹配实现接口的代理对象中的方法
this(com.springlearning.aop.user.UserDAO)
target:匹配实现接口的目标对象中的方法
target(com.springlearning.aop.user.UserDAO)
args:匹配参数格式符合标准的方法
args(int,int)
bean(id) 对指定的bean全部的方法(了解)
bean('userService')

2.3 AspectJ 通知类型

aop联盟定义通知类型，具备特性接口，必须实现，从而肯定方法名称。
aspectj 通知类型，只定义类型名称。已经方法格式。
个数：6种，知道5种，掌握1中
before:前置通知(应用：各类校验)
在方法执行前执行，若是通知抛出异常，阻止方法运行
afterReturning:后置通知(应用：常规数据处理)
方法正常返回后执行，若是方法中抛出异常，通知没法执行
必须在方法执行后才执行，因此能够得到方法的返回值。
around:环绕通知(应用：十分强大，能够作任何事情)
方法执行先后分别执行，能够阻止方法的执行
必须手动执行目标方法
afterThrowing:抛出异常通知(应用：包装异常信息)
方法抛出异常后执行，若是方法没有抛出异常，没法执行
after:最终通知(应用：清理现场)
方法执行完毕后执行，不管方法中是否出现异常

环绕

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

2.4 导入jar包

4个：
aop联盟规范
spring aop 实现
aspect 规范
spring aspect 实现

2.5 基于xml

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

2.5.1 切面类

/**
 * 切面类，含有多个通知
 */
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);
    }
    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 throwable){
        System.out.println("抛出异常通知：" + throwable.getMessage());
    }
    public void myAfter(JoinPoint joinPoint){
        System.out.println("最终通知");
    }
}

2.5.2 spring配置

<!-- 1 建立目标类 -->
    <bean id="userService" class="com.springlearning.aspectj.UserServiceImpl"></bean>
    <!-- 2 建立切面类（通知）-->
    <bean id="myAspect" class="com.springlearning.aspectj.MyAspect"></bean>
    <!-- 3 aop编程
          <aop:aspect> 将切面类 声明“切面”，从而得到通知（方法）
                ref 切面类引用
          <aop:pointcut> 声明一个切入点，全部通知均可以使用。
                expression 切入点表达式
                id 名称，用于其余通知引用
    -->
    <aop:config>
        <aop:aspect ref="myAspect">
            <aop:pointcut id="myPointcut" expression="execution(* com.springlearning.aspectj.UserServiceImpl.*(..))"/>
            <!-- 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:after>

        </aop:aspect>

    </aop:config>

2.6 基于注解

2.6.1 替换bean

<!-- 1 建立目标类 -->
    <bean id="userService" class="com.springlearning.aspectj.UserServiceImpl"></bean>
    <!-- 2 建立切面类（通知）-->
    <bean id="myAspect" class="com.springlearning.aspectj.MyAspect"></bean>

@Component
public class MyAspect {
@Service("userService")
public class UserServiceImpl implements UserService {

注意：扫描

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

    <!-- 1. 扫描 注解类 -->
    <context:component-scan base-package="com.springlearning.aspectj"></context:component-scan>

2.6.2 替换 aop

必须进行aspectj 自动代理

<!-- 2.肯定 aop注解生效 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

声明切面

<aop:aspect ref="myAspect"> <!--被下面注解替换 -->

@Component
@Aspect //添加注解
public class MyAspect {

替换前置通知

<aop:before method="myBefore" pointcut="execution(* com.ithspringlearning.aspectj.UserServiceImpl.*(..))"/> <!--被下面注解替换 -->

//切入点当前有效
    @Before("execution(* com.springlearning.aspectj.UserServiceImpl.*(..))")
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知：" + joinPoint.getSignature().getName());
    }

替换公共切入点

<aop:pointcut id="myPointcut" expression="execution(* com.springlearning.aspectj.UserServiceImpl.*(..))"/>
 <!--被下面注解替换 -->

//声明公共切入点
    @Pointcut("execution(* com.springlearning.aspectj.UserServiceImpl.*(..))")
    private void myPointCut(){}

替换后置

<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />

@AfterReturning(value = "myPointCut()",returning = "ret")
    public void myAfterReturning(JoinPoint joinPoint,Object ret){
        System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    }

环绕替换

<aop:around method="myAround" pointcut-ref="myPointCut"/>

@Around(value = "myPointCut()")
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("前");
        //手动执行目标方法
        Object obj = joinPoint.proceed();
        System.out.println("后");
        return obj;
    }

替换抛出异常

<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="throwable"/>

@AfterThrowing(value = "myPointCut()" ,throwing = "throwable")
    public void myAfterThrowing(JoinPoint joinPoint,Throwable throwable){
        System.out.println("抛出异常通知：" + throwable.getMessage());
    }

2.6.3 切面类

/**
 * 切面类，含有多个通知
 */
@Component
@Aspect
public class MyAspect {

    //声明公共切入点
    @Pointcut("execution(* com.springlearning.aspectj.UserServiceImpl.*(..))")
    private void myPointCut(){}
//    @AfterReturning(value = "myPointCut()",returning = "ret")
    public void myAfterReturning(JoinPoint joinPoint,Object ret){
        System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    }
    //切入点当前有效
 //   @Before("execution(* com.springlearning.aspectj.UserServiceImpl.*(..))")
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知：" + joinPoint.getSignature().getName());
    }

 //   @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 = "throwable")
    public void myAfterThrowing(JoinPoint joinPoint,Throwable throwable){
        System.out.println("抛出异常通知：" + throwable.getMessage());
    }
    @After(value = "myPointCut()")
    public void myAfter(JoinPoint joinPoint){
        System.out.println("最终通知");
    }
}

2.6.4 spring 配置

<!-- 1. 扫描 注解类 -->
    <context:component-scan base-package="com.springlearning.aspectj"></context:component-scan>
    
    <!-- 2.肯定 aop注解生效 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

2.6.5 aop 注解总结

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

3. JdbcTemplate

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

3.1 环境搭建

3.1.1 建立表

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

3.1.2 导入 jar 包

3.1.3 javaBean

public class User {

    private Integer id;
    private String username;
    private String password;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

3.2 使用api

@Test
    public void demo(){
        //1 建立数据源（链接池） dbcp
        BasicDataSource dataSource = new BasicDataSource();
        // * 基本4项
        dataSource.setDriverClassName("oracle.jdbc.driver.OracleDriver");
        dataSource.setUrl("jdbc:oracle:thin:@localhost:1530/orcl");
        dataSource.setUsername("sys as sysdba");
        dataSource.setPassword("sys");
        //2  建立模板
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        //3 经过api操做
        jdbcTemplate.update("insert into t_user(id,username,password) values(?,?,?)","6", "tom","998");
    }

3.3 配置DBCP

<!-- 建立数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
        <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property>
        <property name="url" value="jdbc:oracle:thin:@localhost:1530/orcl"></property>
        <property name="username" value="sys as sysdba"></property>
        <property name="password" value="sys"></property>
    </bean>
    <!-- 建立模板 ,须要注入数据源-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置dao -->
    <bean id="userDao" class="com.springlearning.jdbctemplate.UserDao">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>

3.4 配置C3P0

<!-- 建立C3P0数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="oracle.jdbc.driver.OracleDriver"></property>
        <property name="jdbcUrl" value="jdbc:oracle:thin:@localhost:1530/orcl"></property>
        <property name="user" value="sys as sysdba"></property>
        <property name="password" value="sys"></property>
    </bean>

这儿里注意c3p0的jar包版本，须要mchange-commons-java-0.2.3.包，这是c3p0数据库链接池的辅助包，没有这个包系统启动的时候会报classnotfoundexception，这是c3p0-0.9.2版本后分离出来的包，0.9.1的时候仍是一个包就搞定的

3.5 使用JdbcDaoSupport

3.5.1 dao层

package com.springlearning.jdbctemplate;

import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import java.util.List;

/**
 * @ClassName：UserDao
 * @author: donkey-boy
 * @date:2019/7/19 10:52
 */
public class UserDao extends JdbcDaoSupport {

    /**
      * @Author: donkey-boy
    　* @Description: 更新操做
    　* @Param: user
    　* @Return:  void
    　* @Date: 2019/7/19 15:04
    　*/
    public void update(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);
    }
    /**
      * @Author: donkey-boy
    　* @Description: 查询所有
    　* @Param: []
    　* @Return: java.util.List<com.springlearning.jdbctemplate.User>
    　* @Date: 2019/7/19 15:06
    　*/
    public List<User> findAll(){
        List<User> userList = this.getJdbcTemplate().query("select * from t_user", BeanPropertyRowMapper.newInstance(User.class));
        return userList;
    }

    /**
      * @Author: donkey-boy
    　* @Description: 获取单个用户
    　* @Param: [id]
    　* @Return: com.springlearning.jdbctemplate.User
    　* @Date: 2019/7/19 15:06
    　*/
    public User getUser(int id){
        User user = this.getJdbcTemplate().queryForObject("select * from t_user where id=?", BeanPropertyRowMapper.newInstance(User.class), id);
        return user;
    }
}

3.5.2 spring 配置文件

<!--  配置dao
        * dao 继承 JdbcDaoSupport，以后只须要注入数据源，底层将自动建立模板
    -->
    <!-- 配置dao -->
    <bean id="userDao" class="com.springlearning.jdbctemplate.UserDao">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

3.5.3 源码分析

3.6 配置 properties

3.6.1 properties 文件

jdbc.driverClass=oracle.jdbc.driver.OracleDriver
jdbc.jdbcUrl=jdbc:oracle:thin:@localhost:1530/orcl
jdbc.user=sys as sysdba
jdbc.password=sys

3.6.2 spring 配置

<!-- 加载配置文件 
        "classpath:"前缀表示 src下
        在配置文件以后经过  ${key} 得到内容
    -->
    <context:property-placeholder location="classpath:com/springlearning/jdbctemplate/jdbcInfo.properties"></context:property-placeholder>
    <!-- 建立C3P0数据源 -->
    <bean id="dataSource" 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>

笔记源自传智播客Spring教学设计模式

Spring学习笔记(二)

Spring学习笔记(二)

1. AOP

1.1 AOP介绍

1.1.1 什么是AOP

1.1.2 AOP 实现原理

1.1.2 AOP 术语

1.2 手动方式

1.2.1 JDK 动态代理

1.2.1.1 目标类

1.2.1.2 切面类

1.2.1.3 工厂

1.2.1.4 测试类

1.2.2 CGLIB 字节码加强

1.2.2.1 工厂类

1.3 AOP 联盟通知类型

1.4 spring 编写代理：半自动

1.4.1 目标类

1.4.2 切面类

1.4.3 spring 配置

1.4.4 测试

1.5 spring aop 编程：全自动

1.5.1 spring 配置

1.5.2 测试

2. AspectJ

2.1 介绍

2.2 切入点表达式

2.3 AspectJ 通知类型

2.4 导入jar包

2.5 基于xml

2.5.1 切面类

2.5.2 spring配置

2.6 基于注解

2.6.1 替换bean

2.6.2 替换 aop

2.6.3 切面类

2.6.4 spring 配置

2.6.5 aop 注解总结

3. JdbcTemplate

3.1 环境搭建

3.1.1 建立表

3.1.2 导入 jar 包

3.1.3 javaBean

3.2 使用api

3.3 配置DBCP

3.4 配置C3P0

3.5 使用JdbcDaoSupport

3.5.1 dao层

3.5.2 spring 配置文件

3.5.3 源码分析

3.6 配置 properties

3.6.1 properties 文件

3.6.2 spring 配置