【我在拉勾训练营学技术】绝对值得你收藏的 spring 笔记

peublic class Singleton{
 //静态变量
 private static Singleton sing=new Singleton();
 //构造方法
 private Singleton(){
 }
 //外部调用方法
 public  static Singleton getInstance(){
  return sing;
 }
}

优点：这种方式在类加载时就完成初始化了，获取对象但速度快。避免多线程但同步问题。
缺点：类加载较慢。没有达到懒加载的效果，如果从始至终都未使用果这个实例，这会造成内存的浪费。

public class Singleton{
 private static Singleton sing;
 private Singleton(){
 } 
 private static Singleton getInstance(){
  if(sing==null){
   sing= new Singleton();
  }
  return sing;
 }
}

优点：相对于饿汉，节省资源。
缺点：第一次加载比较慢，且多线程会出现问题。

public class Singleton{
 private Singleton(){
 }
 
 private Static Singleton sing;
 
 public static synchronized Singleton getInstance(){
  if(sing==null){
   sing=new Singleton();
  }
  return sing;
 }
 
}
优点：多线程能够很好的使用
缺点：每次代用getInstance方法都会进行同步操作，造成不必要的同步开销。毕竟大部分时候还是用不到同步的。

public class Singleton(){
 private Singleton(){}
 
 private volalite static Singleton sing;

 public Singleton getInstance(){
  if(sing==null){
   synchronized(Singleton.calss){
    if(sing==null){
     sing= new Singleton();
    }
   }
  }
  return sing;
 }

}

优点：线程安全，避免多余的线程同步，节省资源
缺点：第一次实例比较慢，并且在高并发的情况下可能出现失效

public calss Singleton(){
 private Singleton(){}
 private static class SingletonInner(){
  private static final Singleton sing=new Singleton();
 }
 
 public Singleton getInstance(){
  return SingletonInner.sing;
 }
}

第一次加载 Singleton 类时并不会初始化 sInstance。 只有在第一次调用 getInstance 方法时虚拟机才会加载 SingletonHolder 并初始化 sInstance。

优点：资源利用率高，线程安全，避免多余同步。

Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object result = null;

                        // 前置增强
                       ....
                        // 调用原有业务逻辑
                        result = method.invoke(obj,args);
                        //后置增强
                        ...

                        return result;
                    }
                })

public Object getCglibProxy(Object obj) {
        return  Enhancer.create(obj.getClass(), new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                Object result = null;
                //前置增强
                ...
                result = method.invoke(obj,objects);
                //后置增强
                ...
                return result;
            }
        });
    }

<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:applicationContext.xml</param-value>
 </context-param>
 <!--使⽤监听器启动Spring的IOC容器-->
 <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener
  </listener-class>
 </listener>

<!--告诉ContextloaderListener知道我们使⽤注解的⽅式启动ioc容器-->
 <context-param>
  <param-name>contextClass</param-name>
  <param-value>org.springframework.web.context.support.AnnotationConfigWebAppli
cationContext
 </param-value>
 </context-param>
 <!--配置启动类的全限定类名-->
 <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>com.lagou.edu.SpringConfig</param-value>
 </context-param>
 <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener
  </listener-class>
 </listener>
 

<!--使⽤静态⽅法创建对象的配置⽅式-->
<bean id="userService" class="com.lagou.factory.BeanFactory"
 factory-method="getTransferService"></bean>

<!--使⽤实例⽅法创建对象的配置⽅式-->
<bean id="beanFactory"
class="com.lagou.factory.instancemethod.BeanFactory"></bean> <bean id="transferService" factory-bean="beanFactory" factorymethod="getTransferService"></bean>

单个Bean：xml ：配置lazy-init=true 为开启延迟加载，默认为false.
注解：@lazy

整体Bean：在beans 标签中增加： default-lazy-init 

public interface BeanPostProcessor {
 @Nullable
 default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  return bean;
 }
 @Nullable
 default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  return bean;
 }

}

@FunctionalInterface
public interface BeanFactoryPostProcessor {
 void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

//需要实现它的方法
@Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
 System.out.println(beanFactory);
 BeanDefinition beanDefinition = beanFactory.getBeanDefinition("lagouBean");
  String beanClassName = beanDefinition.getBeanClassName();
 }

public void refresh() throws BeansException, IllegalStateException {
  //加对象锁，避免refresh 和close 同时调用
  synchronized (this.startupShutdownMonitor) {
   /**
    * 第⼀步：刷新前的预处理
    * 刷新的预处理
    * 设置系统启动时间
    * 验证环境信息是否包含必要属性
    */
   prepareRefresh();

   /**
    * 第⼆步：
    *  获取BeanFactory；默认实现是DefaultListableBeanFactory
    *  加载BeanDefinition 并注册到 BeanDefitionRegistry
    */
   ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

   /**
    * 第三步：BeanFactory的预准备⼯作（BeanFactory进⾏⼀些设置，⽐如context的类加
    * 载器等）
    */
   prepareBeanFactory(beanFactory);

   try {
   
    /**
     * 第四步：BeanFactory准备⼯作完成后进⾏的后置处理⼯作
     */
    postProcessBeanFactory(beanFactory);

    /**
     * 第五步：实例化并调⽤实现了 BeanFactoryPostProcessor 接⼝的Bean
     */
    invokeBeanFactoryPostProcessors(beanFactory);

    /**
     *  第六步：注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执
     */
    registerBeanPostProcessors(beanFactory);

    /**
     * 第七步：初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
     */
    initMessageSource();

    /**
     *  第⼋步：初始化事件派发器
     */
    initApplicationEventMulticaster();

    /**
     * 第九步：⼦类重写这个⽅法，在容器刷新的时候可以⾃定义逻辑
     */
    onRefresh();

    /**
     *  第⼗步：注册应⽤的监听器。就是注册实现了ApplicationListener接⼝的监听器
     * bean
     */
    registerListeners();

    /**
     * 第⼗⼀步：
     *  初始化所有剩下的⾮懒加载的单例bean
     *  初始化创建⾮懒加载⽅式的单例Bean实例（未设置属性）
     *  填充属性
     *  初始化⽅法调⽤（⽐如调⽤afterPropertiesSet⽅法、init-method⽅法）
     *  调⽤BeanPostProcessor（后置处理器）对实例bean进⾏后置处
     */
    finishBeanFactoryInitialization(beanFactory);
    
    /**
     * 第⼗⼆步：
     *  完成context的刷新。主要是调⽤LifecycleProcessor的onRefresh()⽅法，并且发布事
     * 件 （ContextRefreshedEvent）
     */
    finishRefresh();
   }
   catch (BeansException ex) {
    ...
   }
   finally {
    resetCommonCaches();
   }
  }
 }

AbstractRefreshableApplicationContextprotected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
  //刷新Beanfactory,调用AbstractRefreshableApplicationContext
  refreshBeanFactory();
  //获取Beanfactory
  return getBeanFactory();
 }

//AbstractRefreshableApplicationContext.java
protected final void refreshBeanFactory() throws BeansException {
  //判断BeanFactory 中是否存在Bean。存在就销毁Bean 并关闭beanfactory
  if (hasBeanFactory()) {
   destroyBeans();
   closeBeanFactory();
  }
  try {
   // 创建一个DefaultListableBeanFactory
   DefaultListableBeanFactory beanFactory = createBeanFactory();
   //序列化beanFactory的id
   beanFactory.setSerializationId(getId());

   //自定义Bean工厂的一些属性
   customizeBeanFactory(beanFactory);
   //加载应用的beanDefitions
   loadBeanDefinitions(beanFactory);
   synchronized (this.beanFactoryMonitor) {
    this.beanFactory = beanFactory;
   }
  }
  catch (IOException ex) {
   throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
  }
 }

*  初始化所有剩下的⾮懒加载的单例bean
*  初始化创建⾮懒加载⽅式的单例Bean实例（未设置属性）
*  填充属性
*  初始化⽅法调⽤（⽐如调⽤afterPropertiesSet⽅法、init-method⽅法）
*  调⽤BeanPostProcessor（后置处理器）对实例bean进⾏后置处

@Override
 public void setBeanName(String name) {
  System.out.println(name);
 }

@Override
 public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
  System.out.println(beanFactory);
 }

@Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  System.out.println(applicationContext);
 }

@Override
 public void afterPropertiesSet() throws Exception {
  System.out.println("afterPropertiesSet");
 }

一级：singletonObjects
二级：earlySingletonObjects
三级：singletonFactories

<beans xmlns="
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
">


<!--aspect   =    切入点（锁定方法） + 方位点（锁定方法中的特殊时机）+ 横切逻辑 -->
    <aop:config>
        <aop:aspect id="logAspect" ref="logUtils">

            <!--切入点锁定我们感兴趣的方法，使用aspectj语法表达式-->
            <!--<aop:pointcut id="pt1" expression="execution(* *..*.*(..))"/>-->
            <aop:pointcut id="pt1" expression="execution(* com.lagou.edu.service.impl.TransferServiceImpl.*(..))"/>


            <!--方位信息,pointcut-ref关联切入点-->
            <!--aop:before前置通知/增强-->
            <aop:before method="beforeMethod" pointcut-ref="pt1"/>
            <!--aop:after，最终通知，无论如何都执行-->
            <!--aop:after-returnning，正常执行通知-->
            <aop:around method="arroundMethod" pointcut-ref="pt1"/>

        </aop:aspect>
    </aop:config>

public class LogUtils {

    /**
     * 业务逻辑开始之前执行
     */
    public void beforeMethod(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            System.out.println(arg);
        }
        System.out.println("业务逻辑开始执行之前执行.......");
    }

    /**
     * 业务逻辑结束时执行（无论异常与否）
     */
    public void afterMethod() {
        System.out.println("业务逻辑结束时执行，无论异常与否都执行.......");
    }

    /**
     * 异常时时执行
     */
    public void exceptionMethod() {
        System.out.println("异常时执行.......");
    }

    /**
     * 业务逻辑正常时执行
     */
    public void successMethod(Object retVal) {
        System.out.println("业务逻辑正常时执行.......");
    }

    /**
     * 环绕通知
     *
     */
    public Object arroundMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知中的beforemethod....");

        Object result = null;
        try{
            // 控制原有业务逻辑是否执行
            // result = proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
        }catch(Exception e) {
            System.out.println("环绕通知中的exceptionmethod....");
        }finally {
            System.out.println("环绕通知中的after method....");
        }

        return result;
    }

}

<!--开启aop注解驱动
    proxy-target-class:true强制使用cglib
-->
<aop:aspectj-autoproxy/>

@Component
@Aspect
public class LogUtils {


    @Pointcut("execution(* com.lagou.edu.service.impl.TransferServiceImpl.*(..))")
    public void pt1(){

    }


    /**
     * 业务逻辑开始之前执行
     */
    @Before("pt1()")
    public void beforeMethod(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            System.out.println(arg);
        }
        System.out.println("业务逻辑开始执行之前执行.......");
    }


    /**
     * 业务逻辑结束时执行（无论异常与否）
     */
    @After("pt1()")
    public void afterMethod() {
        System.out.println("业务逻辑结束时执行，无论异常与否都执行.......");
    }


    /**
     * 异常时时执行
     */
    @AfterThrowing("pt1()")
    public void exceptionMethod() {
        System.out.println("异常时执行.......");
    }


    /**
     * 业务逻辑正常时执行
     */
    @AfterReturning(value = "pt1()",returning = "retVal")
    public void successMethod(Object retVal) {
        System.out.println("业务逻辑正常时执行.......");
    }

    /**
     * 环绕通知
     *
     */
    @Around("pt1()")
    public Object arroundMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知中的beforemethod....");

        Object result = null;
        try{
            // 控制原有业务逻辑是否执行
            // result = proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
        }catch(Exception e) {
            System.out.println("环绕通知中的exceptionmethod....");
        }finally {
            System.out.println("环绕通知中的after method....");
        }

        return result;
    }
}

@EnableAspectJAutoProxy 

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--配置Spring ioc容器的配置类-->
  <context-param>
    <param-name>contextClass</param-name>
    <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
  </context-param>

  <!--配置Spring ioc容器的配置文件-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <!--<param-value>classpath:applicationContext.xml</param-value>-->
    <param-value>com.lagou.edu.config.SpringConfig</param-value>
  </context-param>
  <!--使用监听器启动Spring的IOC容器-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

@EnableTransactionManagement 
@Transactional

DROP TABLE IF EXISTS `account`;
CREATE TABLE `account` (
  `cardNo` varchar(20) NOT NULL,
  `money` int DEFAULT NULL,
  `name` varchar(20) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of account
-- ----------------------------
INSERT INTO `account` VALUES ('6029621011000', '1000', '李大雷');
INSERT INTO `account` VALUES ('6029621011001', '1000', '韩梅梅');

public class Account {

    private String cardNo;
    private String name;
    private int money;
    //getter/setter 方法
}

public class Result {

    private String status;
    private String message;
    //getter/setter 方法
}

public interface AccountDao {

    Account queryAccountByCardNo(String cardNo) throws Exception;

    int updateAccountByCardNo(Account account) throws Exception;
}

public class AccountDaoImpl implements AccountDao {

    private ConnectionUtils connectionUtils=new ConnectionUtils() ;

    @Override
    public Account queryAccountByCardNo(String cardNo) throws Exception {
        Connection con = connectionUtils.getCurrentThreadConn();
        String sql = "select * from account where cardNo=?";
        PreparedStatement preparedStatement = con.prepareStatement(sql);
        preparedStatement.setString(1,cardNo);
        ResultSet resultSet = preparedStatement.executeQuery();

        Account account = new Account();
        while(resultSet.next()) {
            account.setCardNo(resultSet.getString("cardNo"));
            account.setName(resultSet.getString("name"));
            account.setMoney(resultSet.getInt("money"));
        }

        resultSet.close();
        preparedStatement.close();
        return account;
    }

    @Override
    public int updateAccountByCardNo(Account account) throws Exception {

        // 从连接池获取连接
        // 改造为：从当前线程当中获取绑定的connection连接
        Connection con = connectionUtils.getCurrentThreadConn();
        String sql = "update account set money=? where cardNo=?";
        PreparedStatement preparedStatement = con.prepareStatement(sql);
        preparedStatement.setInt(1,account.getMoney());
        preparedStatement.setString(2,account.getCardNo());
        int i = preparedStatement.executeUpdate();

        preparedStatement.close();
        return i;
    }
}

public interface TransferService {

    void transfer(String fromCardNo, String toCardNo, int money) throws Exception;
}



public class TransferServiceImpl implements TransferService{



    private AccountDao accountDao=new AccountDaoImpl();

    @Override
    public void transfer(String fromCardNo, String toCardNo, int money) throws Exception {

            Account from = accountDao.queryAccountByCardNo(fromCardNo);
            Account to = accountDao.queryAccountByCardNo(toCardNo);

            from.setMoney(from.getMoney()-money);
            to.setMoney(to.getMoney()+money);

            accountDao.updateAccountByCardNo(to);
            int c = 1/0;
            accountDao.updateAccountByCardNo(from);
    }
}

@WebServlet(name="transferServlet",urlPatterns = "/transferServlet")
public class TransferServlet extends HttpServlet {


    private TransferService transferService;


    @Override
    public void init() throws ServletException {

        transferService = new TransferServiceImpl();
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        // 设置请求体的字符编码
        req.setCharacterEncoding("UTF-8");

        String fromCardNo = req.getParameter("fromCardNo");
        String toCardNo = req.getParameter("toCardNo");
        String moneyStr = req.getParameter("money");
        int money = Integer.parseInt(moneyStr);

        Result result = new Result();

        try {

            // 2. 调用service层方法
            transferService.transfer(fromCardNo,toCardNo,money);
            result.setStatus("200");
        } catch (Exception e) {
            e.printStackTrace();
            result.setStatus("201");
            result.setMessage(e.toString());
        }

        // 响应
        resp.setContentType("application/json;charset=utf-8");
        resp.getWriter().print(JsonUtils.object2Json(result));
    }
}

public class ConnectionUtils {

    private ThreadLocal<Connection> threadLocal = new ThreadLocal<>(); // 存储当前线程的连接

    /**
     * 从当前线程获取连接
     */
    public Connection getCurrentThreadConn() throws SQLException {
        //判断当前线程中是否已经绑定连接，如果没有绑定，需要从连接池获取一个连接绑定到当前线程
        Connection connection = threadLocal.get();
        if(connection == null) {
            // 从连接池拿连接并绑定到线程
            connection = DruidUtils.getInstance().getConnection();
            // 绑定到当前线程
            threadLocal.set(connection);
        }
        return connection;

    }
}

<?xml version="1.0" encoding="UTF-8" ?>
<!--跟标签beans，里面配置一个又一个的bean子标签，每一个bean子标签都代表一个类的配置-->
<beans>
    <!--id标识对象，class是类的全限定类名-->
    <bean id="accountDao" class="cn.quellanan.dao.impl.AccountDaoImpl">
        <property name="ConnectionUtils" ref="connectionUtils"/>
    </bean>
    <bean id="transferService" class="cn.quellanan.service.impl.TransferServiceImpl">
        <!--set+ name 之后锁定到传值的set方法了，通过反射技术可以调用该方法传入对应的值-->
        <property name="AccountDao" ref="accountDao"></property>
    </bean>


    <!--配置新增的三个Bean-->
    <bean id="connectionUtils" class="cn.quellanan.utils.ConnectionUtils"></bean>

    <!--事务管理器-->
    <bean id="transactionManager" class="cn.quellanan.utils.TransactionManager">
        <property name="ConnectionUtils" ref="connectionUtils"/>
    </bean>

    <!--代理对象工厂-->
    <bean id="proxyFactory" class="cn.quellanan.factory.ProxyFactory">
        <property name="TransactionManager" ref="transactionManager"/>
    </bean>
</beans>

public class BeanFactory {

/**
     * 任务一：读取解析xml，通过反射技术实例化对象并且存储待用（map集合）
     * 任务二：对外提供获取实例对象的接口（根据id获取）*/



    private static Map<String, Object> map = new HashMap<>();  // 存储对象


    static {
        // 加载xml
        InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
        // 解析xml
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(resourceAsStream);
            Element rootElement = document.getRootElement();
            List<Element> beanList = rootElement.selectNodes("//bean");
            for (int i = 0; i < beanList.size(); i++) {
                Element element =  beanList.get(i);
                // 处理每个bean元素，获取到该元素的id 和 class 属性
                String id = element.attributeValue("id");        // accountDao
                String clazz = element.attributeValue("class");  // com.lagou.edu.dao.impl.JdbcAccountDaoImpl
                // 通过反射技术实例化对象
                Class<?> aClass = Class.forName(clazz);
                Object o = aClass.newInstance();  // 实例化之后的对象
                // 存储到map中待用
                map.put(id,o);

            }

            // 实例化完成之后维护对象的依赖关系，检查哪些对象需要传值进入，根据它的配置，我们传入相应的值
            // 有property子元素的bean就有传值需求
            List<Element> propertyList = rootElement.selectNodes("//property");
            // 解析property，获取父元素
            for (int i = 0; i < propertyList.size(); i++) {
                Element element =  propertyList.get(i);   //<property name="AccountDao" ref="accountDao"></property>
                String name = element.attributeValue("name");
                String ref = element.attributeValue("ref");

                // 找到当前需要被处理依赖关系的bean
                Element parent = element.getParent();

                // 调用父元素对象的反射功能
                String parentId = parent.attributeValue("id");
                Object parentObject = map.get(parentId);
                // 遍历父对象中的所有方法，找到"set" + name
                Method[] methods = parentObject.getClass().getMethods();
                for (int j = 0; j < methods.length; j++) {
                    Method method = methods[j];
                    if(method.getName().equalsIgnoreCase("set" + name)) {  // 该方法就是 setAccountDao(AccountDao accountDao)
                        method.invoke(parentObject,map.get(ref));
                    }
                }

                // 把处理之后的parentObject重新放到map中
                map.put(parentId,parentObject);

            }


        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }

    // 任务二：对外提供获取实例对象的接口（根据id获取）
    public static Object getBean(String id) {
        return map.get(id);
    }

}

private ConnectionUtils connectionUtils;

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

public class TransactionManager {

    @Autowired
    private ConnectionUtils connectionUtils;

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

    // 开启手动事务控制
    public void beginTransaction() throws SQLException {
        connectionUtils.getCurrentThreadConn().setAutoCommit(false);
        System.out.println("开启事务.....");
    }


    // 提交事务
    public void commit() throws SQLException {
        connectionUtils.getCurrentThreadConn().commit();
        System.out.println("提交事务.....");
    }

    // 回滚事务
    public void rollback() throws SQLException {
        connectionUtils.getCurrentThreadConn().rollback();
        System.out.println("回滚事务.....");
    }
}

public class ProxyFactory {


    @Autowired
    private TransactionManager transactionManager;


    /**
     * Jdk动态代理
     * @param obj  委托对象
     * @return   代理对象
     */
    public Object getJdkProxy(Object obj) {

        // 获取代理对象
        return  Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object result = null;

                        try{
                            // 开启事务(关闭事务的自动提交)
                            transactionManager.beginTransaction();

                            result = method.invoke(obj,args);
                            //提交
                            transactionManager.commit();

                        }catch (Exception e) {
                            e.printStackTrace();
                            // 回滚事务
                            transactionManager.rollback();

                            // 抛出异常便于上层servlet捕获
                            throw e;

                        }

                        return result;
                    }
                });

    }


    /**
     * 使用cglib动态代理生成代理对象
     * @param obj 委托对象
     * @return
     */
    public Object getCglibProxy(Object obj) {
        return  Enhancer.create(obj.getClass(), new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                Object result = null;
                try{
                    // 开启事务(关闭事务的自动提交)
                    transactionManager.beginTransaction();

                    result = method.invoke(obj,objects);

                    // 提交事务

                    transactionManager.commit();
                }catch (Exception e) {
                    e.printStackTrace();
                    // 回滚事务
                    transactionManager.rollback();

                    // 抛出异常便于上层servlet捕获
                    throw e;

                }
                return result;
            }
        });
    }
}

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    boolean required() default true;
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Component {
    String value() default "";
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Service {
    String value() default "";
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {

    ProxyType type() default ProxyType.DEFAULT;

}

public enum ProxyType {

    //jdk动态代理
    JDK,

    //cglib 动态代理
    CGLIB,

    //默认
    DEFAULT
}

@Service(value = "accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private ConnectionUtils connectionUtils;
    ......
}

@Service
@Transactional
public class TransferServiceImpl implements TransferService{


    @Autowired
    private AccountDao accountDao;
    ......
    
}

public static void searchClass(String basePack) throws Exception {
        Set<String> classPaths = new HashSet<>();
        //先把包名转换为路径,首先得到项目的classpath
        String classpath = BeanFactoryByAnno.class.getResource("/").getPath();
        //然后把我们的包名basPach转换为路径名
        basePack = basePack.replace(".", File.separator);
        //然后把classpath和basePack合并
        String searchPath = classpath + basePack;
        doPath(new File(searchPath),classPaths);
        //这个时候我们已经得到了指定包下所有的类的绝对路径了。我们现在利用这些绝对路径和java的反射机制得到他们的类对象
        for (String s : classPaths) {
            //把绝对路径转换为全类名
            s = s.replace(classpath.replace("/","\\").replaceFirst("\\\\",""),"").replace("\\",".").replace(".class","");
            //处理@Service 注解，实例化对象
            createBeans(s);
        }

        //同理处理@Autowired 注解，为这个属性注入实例化的Bean。
        for (String s : classPaths) {
            //把绝对路径转换为全类名
            s = s.replace(classpath.replace("/","\\").replaceFirst("\\\\",""),"").replace("\\",".").replace(".class","");
            //实例化对象
            populateBean(s);
        }

        //如果包含@Transactional注解，说明需要对这个类进行代理
        for (String s : classPaths) {
            //把绝对路径转换为全类名
            s = s.replace(classpath.replace("/","\\").replaceFirst("\\\\",""),"").replace("\\",".").replace(".class","");
            //代理对象
            ProxyBean(s);
        }

    }

/**
     * 该方法会得到所有的类，将类的绝对路径写入到classPaths中
     * @param file
     */
    private static void doPath(File file,Set<String> classPaths) {
        if (file.isDirectory()) {//文件夹
            //文件夹我们就递归
            File[] files = file.listFiles();
            for (File f1 : files) {
                doPath(f1,classPaths);
            }
        } else {//标准文件
            //标准文件我们就判断是否是class文件
            if (file.getName().endsWith(".class")) {
                //如果是class文件我们就放入我们的集合中。
                classPaths.add(file.getPath());
            }
        }
    }

private static void createBeans(String classPath) throws Exception{
        Class<?> aClass = Class.forName(classPath);
        if (aClass.isAnnotationPresent(Service.class)||aClass.isAnnotationPresent(Component.class) ) {
            // 实例化之后的对象
            Object o = aClass.newInstance();
            //获取key
            String key = getMapKey(aClass);
            // 存储到map中待用
            map.put(key,o);
        }
    }

private static String getMapKey(Class<?> aClass){
        String key = aClass.getSimpleName();

        //获取注解的属性值
        String value="";
        if (aClass.isAnnotationPresent(Service.class)) {
            value = aClass.getAnnotation(Service.class).value();
        }else if(aClass.isAnnotationPresent(Component.class)){
            value=aClass.getAnnotation(Component.class).value();
        }
        if(!value.isEmpty()){
            key=value;
        }
        key=key.toUpperCase();
        return key;
    }

private static void populateBean(String classPath) throws  Exception{
        Class<?> aClass = Class.forName(classPath);
        //获取类的属性
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field field : declaredFields) {
            //如果属性上有注解，则为这个属性填充Bean
            if(field.isAnnotationPresent(Autowired.class)){
                //获取到需要填充属性的类
                Object obj = map.get(getMapKey(aClass));
                //设置属性可以赋值
                field.setAccessible(true);
                //获取到填充的属性
                String name = field.getType().getSimpleName().toUpperCase();
                //通过key 从map 中获取到对象值
                Object value = getMapValue(name);
                //为属性赋值。
                if(value!=null && obj!=null){
                    field.set(obj,value);
                }
            }
        }

    }

private static Object getMapValue(String key){
        key=key.toUpperCase();
        Object value = map.get(key);

        //通过子类子类实现
        if (value == null) {
            value=map.get(key+"IMPL");
        }
        return value;
    }

private static void ProxyBean(String classPath)throws Exception{
        Class<?> aClass = Class.forName(classPath);
        //如果包含事务注解
        if (aClass.isAnnotationPresent(Transactional.class)) {

            //获取实际对象的Bean
            String mapKey = getMapKey(aClass);
            Object mapValue = getMapValue(mapKey);
            //获取代理对象
            ProxyFactory proxyFactory = (ProxyFactory) getMapValue("ProxyFactory");


            //获取 Transactional 注解指定的类型
            ProxyType type = aClass.getAnnotation(Transactional.class).type();
            //判断是否指定了某种代理
            switch (type){
                case JDK:useJdkProxy(proxyFactory,mapKey,mapValue);
                    break;
                case CGLIB:usecGLIBProxy(proxyFactory,mapKey,mapValue);
                    break;
                case DEFAULT:useDefaultProxy(aClass,proxyFactory,mapKey,mapValue);
                default:break;
            }
        }

    }

private static void useDefaultProxy(Class<?> aClass,ProxyFactory proxyFactory,String mapKey,Object mapValue){
        //判读是否包含接口
        Class<?>[] interfaces = aClass.getInterfaces();
        //包含除了自身实现接口外的接口接口
        if(interfaces.length>1){
            useJdkProxy(proxyFactory,mapKey,mapValue);
        }else {
            usecGLIBProxy(proxyFactory, mapKey, mapValue);
       
       }
    }

private static void useJdkProxy(ProxyFactory proxyFactory,String mapKey,Object mapValue){
        Object jdkProxy = proxyFactory.getJdkProxy(mapValue);
        map.put(mapKey,jdkProxy);
    }
    
private static void usecGLIBProxy(ProxyFactory proxyFactory,String mapKey,Object mapValue){
        Object cglibProxy = proxyFactory.getCglibProxy(mapValue);
        map.put(mapKey,cglibProxy);
    }
    

public static Object getBean(String key) {
        return getMapValue(key);
    }

public class ContextListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        String packageName = "cn.quellanan";
        try {
            BeanFactoryByAnno.searchClass(packageName);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("初始化异常。。。。");
        }

    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }
}

private TransferService transferService;

    @Override
    public void init() throws ServletException {
        transferService = (TransferService) BeanFactoryByAnno.getBean("transferService");
    }