SpringAspectJ介绍、切入点表达式、Aspect案例xml配置、Aspect案例注解配置、JdbcTemplate简单使用、DBCP、C3P0配置、db.properties配置-day04

第一节 AspectJ

1.1 AspectJ简介

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

1.2 切入点表达式【掌握】

execution()：用于描述方法 【掌握】

• 语法：execution(修饰符 返回值 包.类.方法名(参数) throws异常)

修饰符，一般省略
public	公共方法
*	任意

返回值，不能省略
void	返回没有值
String	返回值字符串
*	任意

包，[省略]
com.it.crm	固定包
com.it.crm.*.service	crm包下面子包任意 （例如：com.it.crm.staff.service)
com.it.crm..	crm包下面的所有子包（含自己）
com.it.crm.*.service..	crm包下面任意子包，固定目录service，service目录任意包

类，[省略]
UserServiceImpl	指定类
*Impl	以Impl结尾
User*	以User开头
*	任意

方法名，不能省略
addUser	固定方法
add*	以add开头
*Do	以Do结尾
*	任意

(参数)
（）	无参
（int）	一个整型
（int,int）	两个整型
(..)	参数任意

• throws ,可省略，一般不写。

案例1：	execution(* com.it.crm.*.service..*.*(..))
案例2：	< aop:pointcut expression="execution(* com.it.crm.service.*.*(..)) || execution(* com.it.*Do.*(..))" id="myPointCut"/>

这里的空格要去掉<aop:pointcut

within：匹配包或子包中的方法【了解】

within(com.it.aop..*)

this：匹配实现接口的代理对象中的方法【了解】

• this(com.it.aop.user.UserDAO)

target：匹配实现接口的目标对象中的方法【了解】

• target(com.it.aop.user.UserDAO)

args：匹配参数格式符合标准的方法【了解】

• args(int,int)

bean(id)：对指定的bean所有的方法【了解】

• bean(‘userServiceId’)

1.3 AspectJ 通知类型

• aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称。
• aspectj 通知类型，只定义类型名称，以及方法格式。
• 个数：6种，知道5种，掌握1种
  1. before：前置通知(应用：各种校验)
     在方法执行前执行，如果通知抛出异常，阻止方法运行。
  2. afterReturning：后置通知(应用：常规数据处理)
     方法正常返回后执行，如果方法中抛出异常，通知无法执行
     必须在方法执行后才执行，所以可以获得方法的返回值。
  3. around：环绕通知(应用：十分强大，可以做任何事情)
     方法执行前后分别执行，可以阻止方法的执行，必须手动执行目标方法。
  4. afterThrowing：抛出异常通知(应用：包装异常信息)
     方法抛出异常后执行，如果方法没有抛出异常，无法执行。
     
  5. after：最终通知(应用：清理现场)
     方法执行完毕后执行，无论方法中是否出现异常都会执行。
     

1.4 Aspect案例【xml配置】

第一步：导入以下jar包

• spring-aspects-3.2.0.RC2.jar（aspectj实现）
  

第二步：接口与实现类的编写

• 接口UserService

public interface UserService {
     //切面编程
    public void addUser();
    public void updateUser();
    public void deleteUser();
    public int deleteUser(int id);
}

• UserService实现类

public class UserServiceImpl implements UserService{

    @Override
    public void addUser() {
        System.out.println("添加用户...");
    }

    @Override
    public void updateUser() {
        System.out.println("更新用户...");
    }

    @Override
    public void deleteUser() {
        System.out.println("删除用户...");
    }

    @Override
    public int deleteUser(int id) {
        System.out.println("通过id删除用户...");
        return 1;
    }
}

第三步：切面类编写

package com.it.aspect;

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

/**
 * @ClassName MyAspect4
 * @Author shuyy
 * @Date 2020/9/12 
 **/

//切面类：增强代码与切入点的结合
public class MyAspect4 {
    public void myBefore(JoinPoint jp){
        System.out.println("1.前置通知..."+jp.getSignature().getName());//连接点方法名
    }
    /*
      后置通知获取service方法执行后的返回值
      Object retValue：表示service方法执行后的返回值
      如果写了返回值，需要在xml后置通知中配置一个returning，否则报错
    */
    public void myAfterReturning(JoinPoint jp,Object retValue){
        System.out.println("3.后置通知..."+jp.getSignature().getName());
        System.out.println("返回值："+retValue);
    }
    public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("2.环绕通知...开启事务..."+pjp.getSignature().getName());

        //放行
        Object retObj = pjp.proceed();
        System.out.println("4.环绕通知...提交事务...");
        return retObj;
    }
    //ProceedingJoinPoint 可以放行，JoinPoint 没有放行方法
    public void myAfterThrowing(JoinPoint jp,Throwable e){
        System.out.println("异常通知..."+jp.getSignature().getName()+":"+e.getMessage());
    }

    public void myAfter(JoinPoint jp){
        System.out.println("最终通知..."+jp.getSignature().getName());
    }
}

第四步：spring的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:p="http://www.springframework.org/schema/p"
       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/context
                            http://www.springframework.org/schema/context/spring-context.xsd
                            http://www.springframework.org/schema/aop
                            http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--配置UserService-->
    <bean class="com.it.service.UserServiceImpl" id="userService"></bean>
    <!--配置切面类-->
    <bean class="com.it.aspect.MyAspect4" id="myAspect4"></bean>

    <!--配置aop-->
    <aop:config>
        <!--aop:指定切面-->
        <aop:aspect ref="myAspect4">
            <!--aop:指定一个切入点-->
            <aop:pointcut id="myPointcut" expression="execution(* com.it.service.UserServiceImpl.*(..))"/>
            <!--配置前置通知-->
            <aop:before method="myBefore" pointcut-ref="myPointcut"></aop:before>
            <!--配置后置通知-->
            <aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut" returning="retValue"></aop:after-returning>
            <!--配置环绕通知-->
            <aop:around method="myAround" pointcut-ref="myPointcut"></aop:around>
            <!--配置异常通知
            throwing="e"值是方法的参数值
            -->
            <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointcut" throwing="e"></aop:after-throwing>
            <!--配置最终通知：不管有没有异常，最终通知都会执行-->
            <aop:after method="myAfter" pointcut-ref="myPointcut"></aop:after>
        </aop:aspect>
    </aop:config>

</beans>

第五步：测试

• 如果在调用的方法中出现异常，最终通知也会执行
  

1.5 Aspect案例【注解配置】

第一步：声明使用注解

<?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:p="http://www.springframework.org/schema/p"
       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/context
                            http://www.springframework.org/schema/context/spring-context.xsd
                            http://www.springframework.org/schema/aop
                            http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--配置扫描注解的位置-->
    <context:component-scan base-package="com.it"></context:component-scan>

    <!--配置aop注解的生效-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

第二步：替换service和切面bean

• UserService接口与实现类编写同上
• 之前的xml配置
  
• 现在的注解配置
  
  

第三步：声明切面类

第四步：声明前置通知

第五步：声明公共切入点

• 简化代码书写
  

第六步：声明后置通知

第七步：声明环绕通知

第八步：声明异常通知

第九步：声明最终通知

附：切面类代码

package com.it.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @ClassName MyAspect4
 * @Author shuyy
 * @Date 2020/9/13 
 **/

//切面类：增强代码与切入点的结合
@Component
@Aspect
public class MyAspect4 {
    //配置一个公共切入点
    @Pointcut("execution(* com.it.service.UserServiceImpl.*(..))")
    public void myPointcut(){
    }

    @Before("myPointcut()")
    public void myBefore(JoinPoint jp){
        System.out.println("1.前置通知..."+jp.getSignature().getName());//连接点方法名
    }
    /*
      后置通知获取service方法执行后的返回值
      Object retValue：表示service方法执行后的返回值
      如果写了返回值，需要在xml后置通知中配置一个returning，否则报错
    */
    //myPointcut()指向公共切入点，retValue为返回值
    @AfterReturning(pointcut = "myPointcut()",returning = "retValue")
    public void myAfterReturning(JoinPoint jp,Object retValue){
        System.out.println("3.后置通知..."+jp.getSignature().getName());
        System.out.println("返回值："+retValue);
    }
    @Around("myPointcut()")//只有一个值，value可以省略
    public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("2.环绕通知...开启事务..."+pjp.getSignature().getName());
        //放行
        Object retObj = pjp.proceed();
        System.out.println("4.环绕通知...提交事务...");
        return retObj;
    }
    //ProceedingJoinPoint 可以放行，JoinPoint 没有放行方法
    @AfterThrowing(pointcut = "myPointcut()",throwing = "e")
    public void myAfterThrowing(JoinPoint jp,Throwable e){
        System.out.println("异常通知..."+jp.getSignature().getName()+":"+e.getMessage());
    }
    @After("myPointcut()")
    public void myAfter(JoinPoint jp){
        System.out.println("最终通知..."+jp.getSignature().getName());
    }
}

第十步：测试与效果

• 发现注解方式与xml方式效果不同（待解决）
  
• xml配置的效果
  

注解总结

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

第二节：JdbcTemplate

2.1 简介

• jdbcTemplate类似DBUtils，用于操作Jdbc的工具类，它需要依赖于连接池DataSource(数据源)
• JDBC（Java DataBase Connectivity，java数据库连接）是一种用于执行SQL语句的Java API
• ODBC（Open Database Connectivity，ODBC）开放数据库连接，是微软公司开提供了一组对数据库访问的标准API（应用程序编程接口）-SQLServer
• DBCP（DataBase Connection Pool）数据库连接池，是java数据库连接池的一种，由Apache开发
• C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。
• c3p0与dbcp区别
  dbcp没有自动回收空闲连接的功能
  c3p0有自动回收空闲连接功能
  两者主要是对数据连接的处理方式不同！C3P0提供最大空闲时间，DBCP提供最大连接数。C3P0当连接超过最大空闲连接时间时，当前连接就会被断掉。DBCP当连接数超过最大连接数时，所有连接都会被断开。

2.2 环境搭建

第一步：创建数据库和表

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

insert into t_user(username,password) values('jack','520');
insert into t_user(username,password) values('rose','521');

第二步：创建工程导入Jar包

• 在之前的spring工程下即可
  
• 由于idea问题，使用8版本的jar一直连接不上，这里改成5版本的jar
  

第三步：创建JavaBean，数据模型

• 提供get/set
  

2.3 API使用【了解】

	@Test
    public void test1(){
        //1.创建数据源
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        //这里是5版本jar连接8版本mysql需要加上?useUnicode=true&characterEncoding=utf8
        dataSource.setUrl("jdbc:mysql:///spring_day04?useUnicode=true&characterEncoding=utf8");
        dataSource.setUsername("root");
        dataSource.setPassword("root");

        //2.创建jdbcTemplate
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        //更新id为1的username为shu
        jdbcTemplate.update("update t_user set username = ? where id = ?","shu",1);
    }

2.4 配置DBCP

• 掌握一种思想，不自己配置数据源，而使用Spring创建

1. userDao实现类编写

public class UserDaoImpl implements UserDao{

    private JdbcTemplate jdbcTemplate;

    //使用spring依赖注入给它赋值至少要提供set方法
    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

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

    @Override
    public void add(User user) {
        System.out.println("dao添加用户："+user);
        jdbcTemplate.update("insert t_user (username,password) values(?,?)",user.getUsername(),user.getPassword());
    }
}

2. spring的beans.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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="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.xsd">

    <!--配置dateSource对象-->
    <!--
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring_day04?useUnicode=true&characterEncoding=utf8");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
    -->
    <bean class="org.apache.commons.dbcp.BasicDataSource" id="dataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///spring_day04?useUnicode=true&amp;characterEncoding=utf8"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!--配置jdbcTemplate对象-->
    <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--配置dao-->
    <bean class="com.it.dao.UserDaoImpl" id="userDao">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
</beans>

3. 测试与效果

2.5 配置c3p0数据源

• 这样由于数据库版本与jar包不匹配报错，又换成了8版本的jar包并设置了时区
  （unknown system variable ‘tx_isolation’）

	<!--配置c3p0数据源
    注意：dbcp和c3p0的数据库连接的参数的属性名不一样，注意区别
    -->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///spring_day04?serverTimezone=UTC"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

• 还因为jdk版本问题换成了1.8（Unsupported major.minor version 52.0）
  
• 使用c3p0也成功插入数据
  

2.6 使用JdbcDaoSupport简化代码

1. 源码分析

• JdbcDaoSupport内部会设置dateSource，不需要使用jdbcTemplate模板，调用setDateSource后内部会再创建一个jdbcTemplate对象
  

2. dao层代码编写

public class UserDaoImpl extends JdbcDaoSupport implements UserDao{

    //JdbcDaoSupport内部有一个jdbc模板
    @Override
    public void add(User user) {
        System.out.println("dao添加用户："+user);
        //使用super、this调用它都可以，也可以直接写
        getJdbcTemplate().update("insert t_user (username,password) values(?,?)",user.getUsername(),user.getPassword());
    }
}

3. beans1.xml编写
   
4. 效果，数据插入成功
   
   

2.7 配置properties【掌握】

• 将数据库的连接信息配置到一个独立的文件中

1. 在src【也就是类路径】下写一个db.properties
   

driverClass=com.mysql.cj.jdbc.Driver
jdbcUrl=jdbc:mysql:///spring_day04?serverTimezone=UTC
user=root
password=root

2. 在beans1.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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="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.xsd">

    <!--配置dateSource对象-->
    <!--
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring_day04?useUnicode=true&characterEncoding=utf8");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
    -->
    <!--<bean class="org.apache.commons.dbcp.BasicDataSource" id="dataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql:///spring_day04?useUnicode=true&amp;characterEncoding=utf8"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>-->

    <!--读取db.properties数据-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>

    <!--配置c3p0数据源
    注意：dbcp和c3p0的数据库连接的参数的属性名不一样，注意区别
    -->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <property name="driverClass" value="${driverClass}"></property>
        <property name="jdbcUrl" value="${jdbcUrl}"></property>
        <property name="user" value="${user}"></property>
        <property name="password" value="${password}"></property>
    </bean>

    <!--配置jdbcTemplate对象-->
    <!--<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>-->

    <!--配置dao-->
    <bean class="com.it.dao.UserDaoImpl" id="userDao">
        <!--<property name="jdbcTemplate" ref="jdbcTemplate"></property>-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

3. 效果与测试