Java后端 学习路线 笔记汇总表【黑马程序员】

Spring-学习笔记01【Spring框架简介】【day01】Spring-学习笔记02【程序间耦合】Spring-学习笔记03【Spring的IOC和DI】Spring-学习笔记04【Spring的常用注解】【day02】day02资料_dbutilsSpring-学习笔记05【基于XML的IOC的案例】Spring-学习笔记06【Spring的新注解】Spring-学习笔记07【银行转账案例】【day03】Spring-学习笔记08【面向切面编程AOP】Spring-学习笔记09【JdbcTemplate的基本使用】【day04】Spring-学习笔记10【Spring事务控制】

目录

01 今日课程内容介绍

02 案例中添加转账方法并演示事务问题

03 分析事务的问题并编写ConnectionUtils

04 编写事务管理工具类并分析连接和线程解绑

04.1、ConnectionUtils.java

04.2、TransactionManager.java

05 编写业务层和持久层事务控制代码并配置spring的ioc

05.1、bean.xml

06 测试转账并分析案例中的问题

06.1、AccountServiceImpl

07 代理的分析

08 基于接口的动态代理回顾

08.1、IProducer.java

08.2、Producer.java

08.3、Client.java

09 基于子类的动态代理

09.1、pom.xml

09.2、Producer.java

09.3、Client.java

10 使用动态代理实现事务控制

10.1、BeanFactory.java

01 今日课程内容介绍

今日内容

完善我们的account案例分析案例中问题回顾之前讲过的一个技术：动态代理动态代理另一种实现方式解决案例中的问题AOP的概念spring中的AOP相关术语spring中基于XML和注解的AOP配置

02 案例中添加转账方法并演示事务问题

03 分析事务的问题并编写ConnectionUtils

04 编写事务管理工具类并分析连接和线程解绑

04.1、ConnectionUtils.java

package com.itheima.utils;

import javax.sql.DataSource;
import java.sql.Connection;


public class ConnectionUtils {
    private ThreadLocal tl = new ThreadLocal();

    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    
    public Connection getThreadConnection() {
        try {
            //1.先从ThreadLocal上获取
            Connection conn = tl.get();
            //2.判断当前线程上是否有连接
            if (conn == null) {
                //3.从数据源中获取一个连接，并且存入ThreadLocal中
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            //4.返回当前线程上的连接
            return conn;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    
    public void removeConnection() {
        tl.remove();
    }
}

04.2、TransactionManager.java

package com.itheima.utils;


public class TransactionManager {
    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    
    public void beginTransaction() {
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    
    public void commit() {
        try {
            connectionUtils.getThreadConnection().commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    
    public void rollback() {
        try {
            connectionUtils.getThreadConnection().rollback();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    
    public void release() {
        try {
            connectionUtils.getThreadConnection().close();//还回连接池中
            connectionUtils.removeConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

05 编写业务层和持久层事务控制代码并配置spring的ioc

05.1、bean.xml

06 测试转账并分析案例中的问题

06.1、AccountServiceImpl

package com.itheima.service.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;

import java.util.List;


public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public List findAllAccount() {
        return accountDao.findAllAccount();
    }

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }

    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    @Override
    public void deleteAccount(Integer acccountId) {
        accountDao.deleteAccount(acccountId);
    }

    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer...");
        //2.1根据名称查询转出账户
        Account source = accountDao.findAccountByName(sourceName);
        //2.2根据名称查询转入账户
        Account target = accountDao.findAccountByName(targetName);
        //2.3转出账户减钱
        source.setMoney(source.getMoney() - money);
        //2.4转入账户加钱
        target.setMoney(target.getMoney() + money);
        //2.5更新转出账户
        accountDao.updateAccount(source);
        // int i=1/0;
        //2.6更新转入账户
        accountDao.updateAccount(target);
    }
}

07 代理的分析

08 基于接口的动态代理回顾

 

08.1、IProducer.java

package com.itheima.proxy;


public interface IProducer {
    
    public void saleProduct(float money);

    
    public void afterService(float money);
}

08.2、Producer.java

package com.itheima.proxy;


public class Producer implements IProducer {
    
    public void saleProduct(float money) {
        System.out.println("销售产品，并拿到钱：" + money);
    }

    
    public void afterService(float money) {
        System.out.println("提供售后服务，并拿到钱：" + money);
    }
}

08.3、Client.java

package com.itheima.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


public class Client {
    public static void main(String[] args) {
        final Producer producer = new Producer();
        
        IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(),
                new InvocationHandler() {
                    
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //提供增强的代码
                        Object returnValue = null;
                        //1.获取方法执行的参数
                        Float money = (Float) args[0];
                        //2.判断当前方法是不是销售
                        if ("saleProduct".equals(method.getName())) {
                            returnValue = method.invoke(producer, money * 0.8f);
                        }
                        return returnValue;
                    }
                });
        proxyProducer.saleProduct(10000f);
    }
}

09 基于子类的动态代理

09.1、pom.xml

    4.0.0

    com.itheima
    day03_eesy_02proxy
    1.0-SNAPSHOT
    jar

    
        
            cglib
            cglib
            2.1_3
        
    

09.2、Producer.java

package com.itheima.cglib;


public class Producer {
    
    public void saleProduct(float money) {
        System.out.println("销售产品，并拿到钱：" + money);
    }

    
    public void afterService(float money) {
        System.out.println("提供售后服务，并拿到钱：" + money);
    }
}

09.3、Client.java

 

package com.itheima.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;


public class Client {
    public static void main(String[] args) {
        final Producer producer = new Producer();
        
        Producer cglibProducer = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
            
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                //提供增强的代码
                Object returnValue = null;
                //1.获取方法执行的参数
                Float money = (Float) args[0];
                //2.判断当前方法是不是销售
                if ("saleProduct".equals(method.getName())) {
                    returnValue = method.invoke(producer, money * 0.8f);
                }
                return returnValue;
            }
        });
        cglibProducer.saleProduct(12000f);
    }
}

10 使用动态代理实现事务控制

 

10.1、BeanFactory.java

package com.itheima.factory;

import com.itheima.service.IAccountService;
import com.itheima.utils.TransactionManager;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


public class BeanFactory {
    private IAccountService accountService;

    private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }

    public final void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }

    
    public IAccountService getAccountService() {
        return (IAccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if ("test".equals(method.getName())) {
                            return method.invoke(accountService, args);
                        }
                        Object rtValue = null;
                        try {
                            //1.开启事务
                            txManager.beginTransaction();
                            //2.执行操作
                            rtValue = method.invoke(accountService, args);
                            //3.提交事务
                            txManager.commit();
                            //4.返回结果
                            return rtValue;
                        } catch (Exception e) {
                            //5.回滚操作
                            txManager.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            //6.释放连接
                            txManager.release();
                        }
                    }
                });
    }
}

思人恩德想人好处，这是聚光，光则上扬招财招贵；
天天想人不好嫉妒人抱怨人，这叫招阴，阴则下降招病招祸。