package com.lyl.cglibproxy;
public class NBAService {
    public int add(String name,int id){
        System.out.println("NBAService---- add----");
        return id;
    }
}
    public static void main(String[] args) {
//目标对象:没有接口
        NBAService nbaService=new NBAService();
//创建代理对象：选择cglib动态代理
        NBAService proxyService= (NBAService)
                Enhancer.create(nbaService.getClass(),
                        new MethodInterceptor() {//回调函数编写代理规则
                            @Override
                            public Object intercept(Object o, Method method, Object[] objects,
                                                    MethodProxy methodProxy) throws Throwable {
                                try {
                                    System.out.println("开始事务");
                                    Object invoke = methodProxy.invokeSuper(o, objects);//核心
                                    System.out.println("提交事务");
                                    return invoke;
                                }catch (Exception e){
                                    System.out.println("事务回滚");
                                    throw e;
                                }finally {
                                    System.out.println("finally------------");
                                }
                            }
                        });
//代理对象干活
        int res=proxyService.add("huren",1001);
        System.out.println(res);
    }

3.5 SpringAOP

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)

<dependencies>
    <!--spring 核心依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.13.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.2.13.RELEASE</version>
    </dependency>
    <!--测试依赖-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>
<build>
<plugins>
    <!--编译插件-->
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.0</version>
        <configuration>
            <source>1.8</source>
            <target>1.8</target>
        </configuration>
    </plugin>
</plugins>
</build>

public interface IService {
    void add(int id,String name);
    boolean update(int num);
}
package com.kkb.service;
import org.springframework.stereotype.Service;
/**
 * 核心业务类
 */
@Service
public class TeamService implements IService{
    @Override
    public void add(int id, String name) {
        System.out.println("TeamService---- add----");
    }
    @Override
    public boolean update(int num) {
        System.out.println("TeamService---- update----");
//int res=10/0;
        if(num>666){
            return true;
        }
        return false;
    }
}
package com.kkb.service;
import org.springframework.stereotype.Service;
/**
 * 核心业务类
 */
@Service("nbaService")
public class NBAService implements IService{
    @Override
    public void add(int id, String name) {
        System.out.println("NBAService---- add----");
    }
    @Override
    public boolean update(int num) {
        System.out.println("NBAService---- update----");
//int res=10/0;
        if(num>666){
            return true;
        }
        return false;
    }
}

4.定义切面类

package com.lyl.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
/**
 * 切面类
 */
//@Component 切面对象的创建权限依然交给spring容器
//@Aspect  aspectj 框架的注解 标识当前类是一个切面类
public class MyAspect{
    /**
     * 当较多的通知增强方法使用相同的 execution 切入点表达式时，编写、维护均较为麻烦。
     * AspectJ 提供了@Pointcut 注解，用于定义 execution 切入点表达式。
     * 其用法是，将@Pointcut 注解在一个方法之上，以后所有的 execution 的 value 属性值均
     * 可使用该方法名作为切入点。代表的就是@Pointcut 定义的切入点。
     * 这个使用@Pointcut 注解方法一般使用 private 的标识方法，即没有实际作用的方法。
     */
    @Pointcut("execution(* com.kkb.service..*.*(..))")
    private void pointCut(){
    }
    @Pointcut("execution(* com.kkb.service..*.add*(..))")
    private void pointCut2(){
    }
    /**
     * 声明前置通知
     * @param jp
     */
    @Before("pointCut()")
    public void before(JoinPoint jp){
        System.out.println("前置通知：在目标方法执行之前被调用的通知");
        String name = jp.getSignature().getName();
        System.out.println("拦截的方法名称："+name);
        Object[] args = jp.getArgs();
        System.out.println("方法的参数格式："+args.length);
        System.out.println("方法参数列表：");
        for (Object arg : args) {
            System.out.println("\t"+arg);
        }
    }
    /**
     * AfterReturning 注解声明后置通知
     * value： 表示切入点表达式
     * returning 属性表示 返回的结果，如果需要的话可以在后置通知的方法中修改结果
     */
    @AfterReturning(value = "pointCut2()",returning = "result")
    public Object afterReturn(Object result){
        if(result!=null){
            boolean res=(boolean)result;
            if(res){
                result=false;
            }
        }
        System.out.println("后置通知：在目标方法执行之后被调用的通知,result="+result);
        return result;
    }
    /**
     * Around 注解声明环绕通知
     * ProceedingJoinPoint 中的proceed方法表示目标方法被执行
     */
    @Around(value = "pointCut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕方法---目标方法的执行之前");
        Object proceed = pjp.proceed();
        System.out.println("环绕方法---目标方法的执行之后");
        return proceed;
    }
    /**
     * AfterThrowing 注解声明异常通知方法
     * value： 表示切入点表达式
     * returning 属性表示 返回的结果，如果需要的话可以在后置通知的方法中修改结果
     */
    @AfterThrowing(value = "pointCut()",throwing = "ex")
    public void exception(JoinPoint jp,Throwable ex){
//一般会把异常发生的时间、位置、原有都记录下来
        System.out.println("异常通知：在目标方法执行出现异常的时候才会别调用的通知，否则不
                执行");
                System.out.println(jp.getSignature()+"方法出现异常，异常信息
                        是："+ex.getMessage());
    }
    /**
     * After 注解声明为最终通知
     */
    @After( "pointCut()")
    public void myFinally(){
        System.out.println("最终通知：无论是否出现异常都是最后被调用的通知");
    }
}

package com.kkb.test;
import com.lyl.service.NBAService;
import com.lyl.service.TeamService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test01 {
    @Test
    public void test01(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");
        TeamService teamService = (TeamService) ac.getBean("teamService");
        teamService.add(1001,"湖人队");
        System.out.println("--------------------------");
        boolean update = teamService.up
        System.out.println("update 结果="+update);
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
        NBAService nbaService = (NBAService) ac.getBean("nbaService");
        nbaService.add(1002,"热火");
        System.out.println("--------------------------");
        boolean update2 = teamService.update(888);
        System.out.println("update 结果="+update2);
    }
}

<aop:config>
<!--声明切入点的表达式,可以声明多个-->
<aop:pointcut id="pt1" expression="execution(* com.kkb.service..*.add*
        (..))"/>
<aop:pointcut id="pt2" expression="execution(*
        com.kkb.service..*.update*(..))"/>
<aop:pointcut id="pt3" expression="execution(* com.kkb.service..*.del*
        (..))"/>
<aop:pointcut id="pt4" expression="execution(*
        com.kkb.service..*.insert*(..))"/>
<aop:aspect ref="myAOP">
<aop:before method="before" pointcut="execution(*
        com.kkb.service..*.*(..))"></aop:before>
<aop:after-returning method="afterReturn" pointcut-ref="pt2"
        returning="result"></aop:after-returning>
<aop:after-throwing method="exception" pointcut-ref="pt1"
        throwing="ex"></aop:after-throwing>
<aop:after method="myFinally" pointcut-ref="pt1"></aop:after>
<aop:around method="around" pointcut-ref="pt2"></aop:around>
</aop:aspect>

package com.lyl.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
/**
 * 切面类
 */
@Component //切面对象的创建权限依然交给spring容器
@Aspect //aspectj 框架的注解 标识当前类是一个切面类
public class MyAOP {
    public void before(JoinPoint jp){
        System.out.println("AOP前置通知：在目标方法执行之前被调用的通知");
    }
    public void afterReturn(Object result){
        System.out.println("AOP后置通知：在目标方法执行之后被调用的通
                知,result="+result);
    }
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("AOP环绕方法---目标方法的执行之前");
        Object proceed = pjp.proceed();
        System.out.println("AOP环绕方法---目标方法的执行之后");
        return proceed;
    }
    public void exception(JoinPoint jp,Throwable ex){
//一般会把异常发生的时间、位置、原有都记录下来
        System.out.println("AOP异常通知：在目标方法执行出现异常的时候才会别调用的通知，否则
                不执行");
                System.out.println(jp.getSignature()+"方法出现异常，异常信息
                        是："+ex.getMessage());
    }
    public void myFinally(){
        System.out.println("AOP最终通知：无论是否出现异常都是最后被调用的通知");
    }
}

package com.kkb.dao;

import com.lyl.pojo.Team;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

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

public class TeamDao extends JdbcDaoSupport {
    public int getCount() {
        String sql = "select count(tid) from team";
        return this.getJdbcTemplate().queryForObject(sql, Integer.class);
    }

    public Map<String, Object> getMany() {
        String sql = "select max(tid),min(tid) from team";
        return this.getJdbcTemplate().queryForMap(sql);
    }

    /**
     * 自己封装一个处理结果的方法
     *
     * @param resultSet
     * @return
     * @throws SQLException
     */
    public Team handlResult(ResultSet resultSet) throws SQLException {
        Team team = new Team();
        team.setId(resultSet.getInt("tid"));
        team.setName(resultSet.getString("tname"));
        team.setLocation(resultSet.getString("location"));
        return team;
    }

    public List<Team> findAll() {
        String sql = "select * from team";
        return this.getJdbcTemplate().query(sql, new RowMapper<Team>() {
            @Override
            public Team mapRow(ResultSet resultSet, int i) throws SQLException {
/* Team team=new Team();
team.setId(resultSet.getInt("tid"));
team.setName(resultSet.getString("tname"));
team.setLocation(resultSet.getString("location"));*/
                return handlResult(resultSet);
            }
        });
    }

    public Team findById(int id) {
        String sql = "select * from team where tid=?";
        return this.getJdbcTemplate().queryForObject(sql, new Object[]{id}, new
                RowMapper<Team>() {
                    @Override
                    public Team mapRow(ResultSet resultSet, int i) throws SQLException {
/* Team team=new Team();
team.setId(resultSet.getInt("tid"));
team.setName(resultSet.getString("tname"));
team.setLocation(resultSet.getString("location"));*/
                        return handlResult(resultSet);
                    }
                });
    }

    public int insert(Team team) {
//使用JDBCTemplete
// JdbcTemplate template=new JdbcTemplate(dataSource);
        String sql = "insert into team(tname,location) value (?,?)";
        return
                this.getJdbcTemplate().update(sql, team.getName(), team.getLocation());
    }

    public int update(Team team) {
//使用JDBCTemplete
// JdbcTemplate template=new JdbcTemplate(dataSource);
        String sql = "update team set tname=? ,location=? where tid=?";
        return
                this.getJdbcTemplate().update(sql, team.getName(), team.getLocation(), team.getId(
                ));
    }

    public int del(int id) {
//使用JDBCTemplete
// JdbcTemplate template=new JdbcTemplate(dataSource);
        String sql = "delete from team where tid=?";
        return this.getJdbcTemplate().update(sql, id);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--创建数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver">
        </property>
        <property name="jdbcUrl"
                  value="jdbc:mysql://192.168.58.128:3306/springJDBC?
serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=fal
se"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    <!--创建JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--需要注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <bean id="teamDao" class="com.kkb.dao.TeamDao">
        <!--需要JdbcTemplate-->
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
</beans>

测试：

package com.lyl.test;

import com.lyl.dao.TeamDao;
import com.lyl.pojo.Team;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

import java.beans.PropertyVetoException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Test01 {
    ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");

    @Test
    public void testGet() {
        TeamDao dao = (TeamDao) ac.getBean("teamDao");
        int count = dao.getCount();
        System.out.println("查询的总行数：" + count);
        Map<String, Object> many = dao.getMany();
        Set<Map.Entry<String, Object>> entries = many.entrySet();
        for (Map.Entry<String, Object> entry : entries) {
            System.out.println(entry.getKey() + "----" + entry.getValue());
        }
    }

    @Test
    public void testFindAll() {
        TeamDao dao = (TeamDao) ac.getBean("teamDao");
        List<Team> all = dao.findAll();
        for (Team team : all) {
            System.out.println(team);
        }
    }

    @Test
    public void testFindById() {
        TeamDao dao = (TeamDao) ac.getBean("teamDao");
        Team t = dao.findById(2);
        System.out.println(t);
    }

    @Test
    public void testDel() {
        TeamDao dao = (TeamDao) ac.getBean("teamDao");
        int res = dao.del(6);
        System.out.println("删除数据的结果：" + res);
    }

    @Test
    public void testUpdate() {
        ApplicationContext ac = new
                ClassPathXmlApplicationContext("application.xml");
        TeamDao dao = (TeamDao) ac.getBean("teamDao");
        Team team = new Team();
        team.setName("小牛");
        team.setLocation("达拉斯");
        team.setId(4);
        int res = dao.update(team);
        System.out.println("更新数据的结果：" + res);
    }

    @Test
    public void test() {
        ApplicationContext ac = new
                ClassPathXmlApplicationContext("application.xml");
        TeamDao dao = (TeamDao) ac.getBean("teamDao");
        Team team = new Team();
        team.setName("快船1");
        team.setLocation("洛杉矶1");
        int res = dao.insert(team);
        System.out.println("插入数据的结果：" + res);
    }

    @Test
    public void test01() throws PropertyVetoException {
//创建数据源
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://192.168.58.128:3306/springJDBC?
                serverTimezone = UTC & characterEncoding = utf8 & useUnicode = true & useSSL = false");
                dataSource.setUser("root");
        dataSource.setPassword("root");
//使用JDBCTemplete
        JdbcTemplate template = new JdbcTemplate(dataSource);
        String sql = "insert into team(tname,location) value (?,?)";
        int update = template.update(sql, "勇士", "金州");
        System.out.println("插入数据的结果：" + update);
    }
}

package com.lyl.service;

import com.lyl.dao.TeamDao;
import com.lyl.pojo.Team;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class TeamService {
    @Autowired
    private TeamDao teamDao;

    /**
     * @Transactional 属性 说明：
     * readOnly:是否只读
     * <p>
     * rollbackFor={Exception.class}： 遇到什么异常会回滚
     * <p>
     * propagation事务的传播：
     * Propagation.REQUIRED:当前没有事务的时候，就会创建一个新的事务；如果当前有事务，就直
     * 接加入该事务，比较常用的设置
     * Propagation.SUPPORTS:支持当前事务，如果当前有事务，就直接加入该事务；当前没有事务的
     * 时候，就以非事务方式执行
     * Propagation.MANDATORY:支持当前事务，如果当前有事务，就直接加入该事务；当前没有事务的
     * 时候，就抛出异常
     * Propagation.REQUIRES_NEW:创建新事务，无论当前是否有事务都会创建新的
     * <p>
     * isolation=Isolation.DEFAULT：事务的隔离级别：默认是数据库的隔离级别
     */
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor =
            {Exception.class})
    public int insert(Team team) {
        int num1 = teamDao.insert(team);
        System.out.println("第一条执行结果：num1=" + num1);
        System.out.println(10 / 0);
        int num2 = teamDao.insert(team);
        System.out.println("第二条执行结果：num2=" + num2);
        return num2 + num1;
    }
}

@Test
public void test01(){ 
    ApplicationContext ac=new ClassPathXmlApplicationContext("application.xml"); 
    TeamService teamService = (TeamService) ac.getBean("teamService"); 
    int num=teamService.insert(new Team("凯尔特人","波士顿")); 
    System.out.println(num); 
}

<!--配置文件中添加context约束-->
<context:component-scan base-package="com.lyl"/>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>

6.4 基于XML的事务

<dependency>
    <groupId>org.aspectj</groupId> 
    <artifactId>aspectjweaver</artifactId> 
    <version>1.9.6</version> 
</dependency>

<!-- 事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean> <tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
    <tx:method name="insert*" propagation="REQUIRED"/>
    <tx:method name="add*" propagation="REQUIRED"/>
    <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
</tx:attributes>
</tx:advice> <aop:config>
<aop:pointcut id="pt" expression="execution(* com.kkb.service..*.* (..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
</aop:config>