public class User {
    public void add() {
        System.out.println("add.............");
    }
}

class UserService{
    execute();
    UserDao dao = new UserDao();
    dao.add();
}

class UserDao{
    add() {
        ...
    }
}

class UserService{
    execute();
    UserDao dao = UserFactory.getDao();
    dao.add();
}

class UserDao{
    add() {
        ...
    }
}

class UserFactory{
    public static UserDao getDao() {
        return new UserDao();
    }
}

<bean id="user" class="com.learn.User"></bean>

class UserFactory{
    public static UserDao getDao() {
        // 1. xml encoding
        String classValue = class属性;
        // 2. use reflect create an object
        Class clazz = Class.for(Name);
        return (UserDao)clazz.newInstance();
    }
}

public void setBname(String bname) {
    this.bname = bname;
}

public class Orders{
    private String oname;
    private String address;

    public Order(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}

// service and dao objects: 在service层创建UserDAO类，生成set方法
<bean id="userService" class="com.learn.service.UserService">
// inject userDao object
// name attribute: class attribute name private UserDao userDao;
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.learn.dao.UserDaoImpl"></bean>

public class Dept {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }
}

public class Emp {
    private String ename;
    private Dept dept;
    public void setDept(Dept dept) {
        this.dept = dept;
    }
}

// inner bean
<bean id="emp" class="com.learn.bean.Emp">
// inject userDao object
<property name="ename" value="lucy"></property>
// method 1
// <property name="dept" ref="dame"></property>
// method 2
<property name="dept">
    <bean id="dept" class="com.learn.bean.Dept">
    <property name="dname" value="IT"></property>
</property>
</bean>

public class Stu {
    // array
    private String[] courses;
    // list
    private List<String> list;

    // map
    private Map<String, String> maps;

    // set
    private Set<String> sets;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }
      
    public void setList( List<String> list) {
        this.list =  list;
    }
    public void setMap(Map<String, String> maps) {
        this.maps =  maps;
    }
    public void setSet(Set<String> sets) {
        this.sets =  sets;
    }
}

<bean id="stu" class="com.learn.conllectiontype.Stu">

// array
<property name="courses">
    <array>
        <value>java class </value>
        <value>sql class </value>
    </array>
</property>

// list
<property name="list">
    <list>
        <value>AAA </value>
        <value>BBB class </value>
    </list>
</property>

// MAP
<property name="maps">
    <map>
        <entry>key="JAVA" value="jva"</entry>
        <entry>key="PHP" value="php"</entry>
    </map>
</property>

// set
<property name="sets">
    <set>
       <value>MySQL </value>
        <value>Redis </value>
    </set>
</property>
</bean>

public class Course {
    private String cname;
    public void setCname(String cname) {
        this.cname = cname;
    }

    public String toString() {

    }

}

public class Stu {
    // array
    private String[] courses;
    // list
    private List<String> list;

    // map
    private Map<String, String> maps;

    // set
    private Set<String> sets;

    // ===============coursed students take===============
    private List<Course> courseList;

    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }
    // ===============coursed students take===============

    public void setCourses(String[] courses) {
        this.courses = courses;
    }
      
    public void setList( List<String> list) {
        this.list =  list;
    }
    public void setMap(Map<String, String> maps) {
        this.maps =  maps;
    }
    public void setSet(Set<String> sets) {
        this.sets =  sets;
    }
}

<bean id="stu" class="com.learn.conllectiontype.Stu">

// array
<property name="courses">
    <array>
        <value>java class </value>
        <value>sql class </value>
    </array>
</property>

// list
<property name="list">
    <list>
        <value>AAA </value>
        <value>BBB class </value>
    </list>
</property>

// MAP
<property name="maps">
    <map>
        <entry>key="JAVA" value="jva"</entry>
        <entry>key="PHP" value="php"</entry>
    </map>
</property>

// set
<property name="sets">
    <set>
       <value>MySQL </value>
        <value>Redis </value>
    </set>
</property>
</bean>

// ===============inject list collection type, value is object===============
<property name="courseList">
    <list>
       <ref bean="course1"></ref>
       <ref bean="course2"></ref>
    </list>
</property>
// ===============create multiple course objects===============
<bean id="course1" class="com.learn.collectiontype.Course">
    <property name="cname" value="Spring5"></property>
</bean>
<bean id="course2" class="com.learn.collectiontype.Course">
    <property name="cname" value="MyBatis"></property>
</bean>

public class Book {
    private List<String> list;
    public void setList(List<String> list) {
        this.list = list;
    }

    public String toString() {
        
    }

    public void test() {
        System.out.println(list);
    }

}

<bean xmlns=""
      xmlns:p=""
    //   copy xmlns:p
      xmlns:util="http://www.springframework.org/schema/util"

    //   change xsi:schemaLocation beans to util
    //   xsi:schemaLocation="http://www.springframework.org/schema/beans" "http://www.springframework.org/schema/beans/spring-beans.xsd"
      xsi:schemaLocation="http://www.springframework.org/schema/util" "http://www.springframework.org/schema/util/spring-util.xsd">

// 1. list=====================
<util:list id="bookList">
        <value>AAA </value>
        <value>BBB</value>
        <value>CCC</value>
</util:list>

@Test
public void testCollection() {
    ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
Book book = context.getBean("book", Book.class);
book.test();
}

    <context:component-scan base-package="com.learn"></context:component-scan>

    <context:component-scan base-package="com.learn" use-default-filter="false">
        <context:include-filter type="anotation" expreesion="org.springframework.steretype.Controller">
    </context:component-scan>

interface UserDao {
    public void login();
}

class UserDao implements UserDao{
    public void login() {
        // 登录实现过程
    }
}

class User {
    public void add() {
        。。。。
    }
}

class Person extends User{
    public void add() {
        super.add();
    }
}

    public interface Userdao {

    int add(int a, int b);

    String update(String id);

}

    public class UserDaoImpl implements Userdao{
    @Override
    public int add(int a, int b) {
        System.out.println("add方法之前执行le");
        return a + b;
    }

    @Override
    public String update(String id) {
        System.out.println("update方法之前执行le");
        return id;
    }
}

    public class UserDaoImpl implements Userdao{
    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

public class JDKProxy {
    public static void main(String[] args) {

        Class[] interfaces = {UserDao.class};

        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
           @Override
           public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               return null;
           }
        });
    }

public class JDKProxy {
    public static void main(String[] args) {

        Class[] interfaces = {UserDao.class};
        ...
    }
}

class UserDaoProxy implements InvocationHandler {
      // 1. 把创建的是谁的代理对象，把谁传递过来
     // 有参数构造传递
     private Object obj;
     public UserDaoProxy(Object obj) {
         this.obj = obj;
     }
     // 增加的逻辑
         // 增加的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
         // 方法之前
        System.out.println("方法之前执行.............." + method.getName() + " : 传递的参数" + Arrays.toString(args));
        Object res = method.invoke(obj, args);
        System.out.println("方法之后执行..........." + obj);
        return res;
    }
}   

public class JDKProxy {
    public static void main(String[] args) {

        Class[] interfaces = {UserDao.class};

        UserDaoImpl userDao = new UserDaoImpl();

        UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));

         int result = dao.add(1, 2);
        System.out.println(result);
    }
}

public class User {
    public void add() {
        System.out.println("add...........");
    }
}

// 增强类
public class UserProxy {

    // 前置通知
    public void before() {
        System.out.println("before......................");
    }
}

// 增强类
@Component
@Aspect // 生成代理对象
public class UserProxy {

    // 前置通知
    public void before() {
        System.out.println("before......................");
    }
}

// 增强类
@Component
@Aspect // 生成代理对象
public class UserProxy {

    // 前置通知
    // @Before 注解表示作为配置通知
    @Before("execution(*com.learn.aop.User.add(..)")
    public void before() {
        System.out.println("before......................");
    }
}

    <bean id="book" class="com.learn.aopxml.Book"></bean>
    
    <bean id="bookProxy" class="com.learn.aopxml.BookProxy"></bean>

    <!--JdbcTemplate 对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

        <!--set方法注入dataSource-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

<!--4.1 开启组件扫描-->
    <context:component-scan base-package="com.learn"/>

@Service
public class BookService {

    // 注入dao
    @Autowired
    private BookDao bookDao ;
}

@Repository
public class BookDaoImpl implements BookDao{

    // 注入jdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

@Repository
public class BookDaoImpl implements BookDao{

    // 注入jdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    // 添加的方法
    @Override
    public void add(Book book) {
        // 1. 创建 sql 语句
        String sql = "insert into t_book values(?, ?, ?)";
        // 2. 调用方法实现
        int update = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getUstatus());

        System.out.println(update);
    }
       
    // 删除的方法
    @Override
    public void del(String id) {
        // 1. 创建 sql 语句
        String sql = "delete from t_book where user_id=?";
        // 2. 调用方法实现
        int update = jdbcTemplate.update(sql, id);

        System.out.println(update);
    }
           // 更新的方法
    @Override
    public void update(Book book) {
        // 1. 创建 sql 语句
        String sql = "update t_book set username=?, ustatus=? where user_id=?";
        // 2. 调用方法实现
       Object[] args = {book.getUserId(), book.getUsername(), book.getUstatus()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

}

    @Test
    public void testAdd() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);
        Book book = new Book();
        book.setUserId("2");
        book.setUsername("bb");
        book.setUstatus("b");
        bookService.addBook(book);
    }

    @Override
    public int selectCount() {
        String sql = "select count(*) from t_book";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count;
    }

   public Book findBookInfo(String id) {
        String sql = "select * from t_book where user_id=?";
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
        return book;
    }

    @Override
    public List<Book> findAll() {
        String sql = "select * from t_book";
        List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        return bookList;
    }

  @Override
    public void batchAddBook(List<Object[]> batchArgs) {
        String sql = "insert into t_book values(?, ?, ?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(ints);
         System.out.println(Arrays.toString(ints));

    }

    public void test3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"6", "hava", "w"};
        Object[] o2 = {"7", "gwe", "we"};
        Object[] o3 = {"8", "cge", "h"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchAdd(batchArgs);

    @Override
    public void batchUpdateBook(List<Object[]> batchArgs) {
        String sql = "update t_book set user_name=?, ustatus=? where user_id=?";
         int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));

    }

    public void test3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> batchArgs = new ArrayList<>();
        // Object[] o1 = {"6", "hava", "w"};
        // Object[] o2 = {"7", "gwe", "we"};
        // Object[] o3 = {"8", "cge", "h"};
        // update t_book set user_name=?, ustatus=? where user_id=? id放最后
        Object[] o1 = { "hava001", "w","6",};
        Object[] o2 = { "hava002", "w","7",};
        Object[] o3 = { "hava003", "w","8",};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchAdd(batchArgs);

    public void batchDeleteBook(List<Object[]> batchArgs) {
        String sql = "delete from t_book  where user_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

    public void test3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);

        List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = { "6"};
        Object[] o2 = { "7"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        bookService.batchDelate(batchArgs);

@Service
public class UserService {

    @Autowired
    private UserDao userDao;
}

@Repository
public class UserDaoImpl implements UserDao{

    @Autowired
    private JdbcTemplate jdbcTemplate;
}

<!--    引入外部属性文件-->
    <context:property-placeholder location="jdbc.properties"/>


<!--4.1 开启组件扫描-->
    <context:component-scan base-package="com.learn"/>


    <!--数据库连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="url" value="${prop.url}"/>
        <property name="username" value="${prop.userName}"/>
        <property name="password" value="${prop.password}"/>
        <property name="driverClassName" value="${prop.driverClass}"/>
    </bean>


    <!--JdbcTemplate 对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

        <!--set方法注入dataSource-->
        <property name="dataSource" ref="dataSource"/>
    </bean>


</beans>

@Transactional(propogation = Propagation.REQUIRED, isolation = Isolation.REPEATABLE_READ)
public void add() {
    // call update method
    update();
}

public void update() {

}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:bean1.xml")
//   ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
public class JTest4 {
    @Autowired
    private UserService userService;

    @Test
    public void test1() {

    }
}

@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:bean1.xml")
//   ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
public class JTest4 {
    @Autowired
    private UserService userService;

    @Test
    public void test1() {

    }
}



+ 2. JUnit5 复合注解

```java

@SpringJunitConfig(lacation="classpath:bean1.xml")
//   ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
public class JTest4 {
    @Autowired
    private UserService userService;

    @Test
    public void test1() {

    }
}

        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-core</artifactId>
            <version>3.4.13</version>
        </dependency>

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
            <version>2.4.1</version>
        </dependency>

name    varcher     255 username
money   int         255 balance
cardNo  varcher     255 bank account

@WebServlet(name = "transerServlet", urlPatterns = "/transferServlet")
public class TransferServlet extends HttpServlet {
    // create service instance
    private TransferService transferService = new TransferServiceImpl();

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

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

        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 {
            // invoke service method
            transferService.transfer(fromCardNo,toCardNo,money);
            result.setStatus("200");
        } catch (Exception e) {
            e.printStackTrace();
            result.setStatus("201");
            result.setMessage(e.toString());
        }

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

public interface TransferService {
    void transfer(String fromCardNo, String toCardNo, int money) throws Exception;
}

public class TransferServiceImpl implements TransferService {

    private AccountDao accountDao = new JdbcAccountDaoImpl();

    @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);
            accountDao.updateAccountByCardNo(from);
    }
}

public interface AccountDao {

    /**
     * get account by query accountNo
     * @param cardNo
     * @return
     * @throws Exception
     */
    Account queryAccountByCardNo(String cardNo) throws Exception;

    /**
     * up aacount information
     * @param account
     * @return
     * @throws Exception
     */
    int updateAccountByCardNo(Account account) throws Exception;
}

public class JdbcAccountDaoImpl implements AccountDao {

    @Override
    public Account queryAccountByCardNo(String cardNo) throws Exception {
        
        Connection con = DruidUtils.getInstance().getConnection();
        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();
        con.close();

        return account;
    }

    @Override
    public int updateAccountByCardNo(Account account) throws Exception {
        
        Connection con = DruidUtils.getInstance().getConnection();
        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();
        con.close();
        return i;
    }
}

public class TransferServiceImpl implements TransferService {

    // private AccountDao accountDao = new JdbcAccountDaoImpl();
    private AccountDao accountDao；

    // @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);
    //         accountDao.updateAccountByCardNo(from);
    // }
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
}

factory read xml file, 
use reflection to instantiate the object,
defines an interface for creating objects

xml:
com.test.dao.JdbcAccountDaoImpl
com.test.service.TransferServiceImpl

<?xml version="1.0" encoding="UTF-8" ?>

<!--each bean represent a class-->
<beans>
    
    <bean id="accountDao" class="com.test.dao.impl.JdbcAccountDaoImpl">
        <property name="ConnectionUtils" ref="connectionUtils"/>
    </bean>

    <bean id="transferService" class="com.test.service.impl.TransferServiceImpl">
        <!--set+ name, Method injectione -->
        <property name="AccountDao" ref="accountDao"></property>
    </bean>
</beans>

/* 
* factory class
* task1: read xml, use reflection to instantiate the object, store in the map
* task2: provide interfaces for creating objects (id)
*/
public class BeanFactory {

    private static Map<String, Object> map = new HashMap<>(); // store object


    /* 
    * read xml, use reflection to instantiate the object, store in the map
    */
    static {
        // load xml
        InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml")
        // read xml
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.getRootElement();
            Element rootElement = document.getRootElement();
            List<Element> beanList = rootElement.selectNodes("//bean");
            for (int i = 0; i < beanList.size(); i++) {
                Element element =  beanList.get(i);
                // get bean id 和 class property
                String id = element.attributeValue("id");        // accountDao
                String clazz = element.attributeValue("class");  // com.test.dao.impl.JdbcAccountDaoImpl
                // use reflection to instantiate the object
                Class<?> aClass = Class.forName(clazz);
                Object o = aClass.newInstance();

                // store in the map
                map.put(id, o);
        }

        // pass property of the bean into Oject
        List<Element> propertyList = rootElement.selectNodes("//property");
        // read property, get super element
        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");

            // find parent
            Element parent = element.getParent();

            // call parent element reflection
            String parentId = parent.attributeValue("id");
            Object parentObject = map.get(parentId);
            // search all the methods
            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));
                }
            }

            // put parentObject back into 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();
        }
    }

    /* 
    * provide interfaces for creating objects (id) 
    * @param id
    * @return
    */
    public static Object getBean(String id) {
        return map.get(id);
    }
}

@WebServlet(name = "transerServlet", urlPatterns = "/transferServlet")
public class TransferServlet extends HttpServlet {
    // create service instance
    // private TransferService transferService = new TransferServiceImpl();

    // get service object through BeanFactory
    private TransferService transferService = (TransferService) BeanFactory.getBean("transferService");

    
    public class TransferServiceImpl implements TransferService {
        // get Dao object through BeanFactory
        // private AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");

        // better way
        private AccountDao accountDao;

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

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

/**
 * get connection
 */
public class ConnectionUtils {

    private ThreadLocal<Connection> threadLocal = new ThreadLocal<>(); // store current threadlocal

    /**
     * connection from thread
     */
    public Connection getCurrentThreadConn() throws SQLException {
       
        Connection connection = threadLocal.get();
        if(connection == null) {
            // get connection
            connection = DruidUtils.getInstance().getConnection();
            // put into threadlocal
            threadLocal.set(connection);
        }
        return connection;
    }
}

public class TransactionManager {

    private ConnectionUtils connectionUtils;

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

    // begin transaction
    public void beginTransaction() throws SQLException {
        connectionUtils.getCurrentThreadConn().setAutoCommit(false);
    }

    // commit transaction
    public void commit() throws SQLException {
        connectionUtils.getCurrentThreadConn().commit();
    }

    // rollback
    public void rollback() throws SQLException {
        connectionUtils.getCurrentThreadConn().rollback();
    }
}

public class ProxyFactory {

    private TransactionManager transactionManager;

    public void setTransactionManager(TransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    /* 
    Jdk Dynamic Proxy
    @param obj
    @return proxy object
    */
    public Object getJdkProxy(Object obj) {

        // get proxy object
        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();
                    // throw e can be caught by servlet
                    throw e;
                }
                return result;

                }
            }
        });
    }

    /* 
    * cglib get Dynamic Proxy
    @param obj
    @return proxy object
    */
    public Object getCglibProxy(Object obj) {

        // get proxy object
        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();
                    // throw e can be caught by servlet
                    throw e;
                }
                return result;

                }
            }
        });
    }
}

<?xml version="1.0" encoding="UTF-8" ?>

<!--each bean represent a class-->
<beans>
    
    <bean id="accountDao" class="com.test.dao.impl.JdbcAccountDaoImpl">
        <property name="ConnectionUtils" ref="connectionUtils"/>
    </bean>

    <bean id="transferService" class="com.test.service.impl.TransferServiceImpl">
        <!--set+ name, Method injectione -->
        <property name="AccountDao" ref="accountDao"></property>
    </bean>

<!--add three new bean-->
<bean id="connectionUtils" class="com.test.utils.ConnectionUtils">
</bean>

<!--transactionManager bean-->
 <bean id="transactionManager" class="com.test.utils.TransactionManager">
        <property name="ConnectionUtils" ref="connectionUtils"/>
    </bean>
 <!--ProxyFactory-->
    <bean id="proxyFactory" class="com.test.factory.ProxyFactory">
        <property name="TransactionManager" ref="transactionManager"/>
    </bean>   
</beans>

public class JdbcAccountDaoImpl implements AccountDao {

    private ConnectionUtils connectionUtils;

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

    @Override
    public Account queryAccountByCardNo(String cardNo) throws Exception {
        
        // Connection con = DruidUtils.getInstance().getConnection();
        // get connection from threadlocal
        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();
        con.close();

        return account;
    }

    @Override
    public int updateAccountByCardNo(Account account) throws Exception {
        
        // Connection con = DruidUtils.getInstance().getConnection();
        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();
        // con.close();
        return i;
    }
}

@WebServlet(name = "transerServlet", urlPatterns = "/transferServlet")
public class TransferServlet extends HttpServlet {
    // create service instance
    // private TransferService transferService = new TransferServiceImpl();

    // get service object through BeanFactory
    // private TransferService transferService = (TransferService) BeanFactory.getBean("transferService");

    // get proxy object from factory
    private ProxyFactory proxyFactory = (ProxyFactory) BeanFactory.getBean("proxyFactory");
    private TransferService transferService = (TransferService) proxyFactory.getProxy(BeanFactory.getBean("transferService"));

    @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. call service method
            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 TransferServiceImpl implements TransferService {

   
    private AccountDao accountDao;

   

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

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

        try{
            
            TransactionManager.getInstance().beginTransaction();*/

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

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

            accountDao.updateAccountByCardNo(to);
            // make a error to test
            int c = 1/0;
            accountDao.updateAccountByCardNo(from);
            
            TransactionManager.getInstance().commit();
        }catch (Exception e) {
            e.printStackTrace();
            
            TransactionManager.getInstance().rollback();
            
            throw e;
        }
    }
}

init() {
    new ApplicationContext() {
        reader = new BeanDefinitionReader();
        reader.loadBeanDefinitions();

        factory.doRegistryBeanDefinition() {
            beanDefinitionMap.put()
        }

        doLoadInstance() {
            getBean() //循环调用
        }
    }
}

getBean() {
    BeanDefinition beanDefinition = registry.beanDefinitionMap.get(beanName);

    Object instance = instantiateBean();

    BeanWrapper beanWrapper = new BeanWrapper(instance);

    factoryBeanInstanceCache.put(beanWrapper);

    populateBean(); //依赖注入
}

public class BeanFactory {
	private Map<String, Object> beanMap = new HashMap<>();

	public void registerBean(String name, Object bean) {
		beanMap.put(name, bean);
	}

	public Object getBean(String name) {
		return beanMap.get(name);
	}
}

public class SimpleBeanContainerTest {

	@Test
	public void testGetBean() throws Exception {
		BeanFactory beanFactory = new BeanFactory();
		beanFactory.registerBean("helloService", new HelloService());
		HelloService helloService = (HelloService) beanFactory.getBean("helloService");
		assertThat(helloService).isNotNull();
		assertThat(helloService.sayHello()).isEqualTo("hello");
	}

	class HelloService {
		public String sayHello() {
			System.out.println("hello");
			return "hello";
		}
	}
}

package org.springframework.beans;
public class BeanDefinitionAndBeanDefinitionRegistryTest {

	@Test
	public void testBeanFactory() throws Exception {
		DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
		BeanDefinition beanDefinition = new BeanDefinition(HelloService.class);
		beanFactory.registerBeanDefinition("helloService", beanDefinition);

		HelloService helloService = (HelloService) beanFactory.getBean("helloService");
		helloService.sayHello();
	}
}

class HelloService {
	public String sayHello() {
		System.out.println("hello");
		return "hello";
	}
}

service() {                                                        service() {
    doXxx(); //具体业务代码，但是父类无法知道子类具体业务逻辑，  <= 继承  doXxx();
    //所以后抽象惩罚让子类重写                                         }
}

protected void doXxx() {                                   <= 覆盖 void doXxx() {
    //空实现，或者默认实现                                          //具体实现
}                                                                   }

public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

public User getUser(T t){...}

Constructor constructors = birdClass.getConstructor(new Class[]{String.class});
            Class[] parameterTypes = constructors.getParameterTypes();

Class birdClass = Bird.class;
Constructor[] constructors = birdClass.getConstructors();

public class Alunbar {
    public static void  main(String arts[]){

        Class birdClass = Bird.class;
        try{
            Constructor constructors = birdClass.getConstructor(new Class[]{String.class});
        }catch(NoSuchMethodException  e){

        }
    }

    private class Bird {
        public Bird(){

        }

        public Bird(String eat){

        }
    }
}

    // 子类应该重写该方法
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }

@Override
public Class<?> findClass(String name) throws ClassNotFoundException {
	try {
		/*自己另外写一个getClassData()
                  通过IO流从指定位置读取xxx.class文件得到字节数组*/
		byte[] datas = getClassData(name);
		if(datas == null) {
			throw new ClassNotFoundException("类没有找到：" + name);
		}
		//调用类加载器本身的defineClass()方法，由字节码得到Class对象
		return defineClass(name, datas, 0, datas.length);
	} catch (IOException e) {
		e.printStackTrace();
		throw new ClassNotFoundException("类找不到：" + name);
	}
}

public class Calculator {

	//加
	public int add(int a, int b) {
		int result = a + b;
		return result;
	}

	//减
	public int subtract(int a, int b) {
		int result = a - b;
		return result;
	}

	//乘法、除法...
}

public class Calculator {

	//加
	public int add(int a, int b) {
		System.out.println("add方法开始...");
		int result = a + b;
		System.out.println("add方法结束...");
		return result;
	}

	//减
	public int subtract(int a, int b) {
		System.out.println("subtract方法开始...");
		int result = a - b;
		System.out.println("subtract方法结束...");
		return result;
	}

	//乘法、除法...
}

/**
 * 目标对象实现类，实现Calculator接口
 */
public class CalculatorImpl implements Calculator {

	//加
	public int add(int a, int b) {
		int result = a + b;
		return result;
	}

	//减
	public int subtract(int a, int b) {
		int result = a - b;
		return result;
	}

	//乘法、除法...
}

/**
 * 代理对象实现类，实现Calculator接口
 */
public class CalculatorProxy implements Calculator {
        //代理对象内部维护一个目标对象引用
	private Calculator target;
        
        //构造方法，传入目标对象
	public CalculatorProxy(Calculator target) {
		this.target = target;
	}

        //调用目标对象的add，并在前后打印日志
	@Override
	public int add(int a, int b) {
		System.out.println("add方法开始...");
		int result = target.add(a, b);
		System.out.println("add方法结束...");
		return result;
	}

        //调用目标对象的subtract，并在前后打印日志
	@Override
	public int subtract(int a, int b) {
		System.out.println("subtract方法开始...");
		int result = target.subtract(a, b);
		System.out.println("subtract方法结束...");
		return result;
	}

	//乘法、除法...
}

public class Test {
	public static void main(String[] args) {
		//把目标对象通过构造器塞入代理对象
		Calculator calculator = new CalculatorProxy(new CalculatorImpl());
		//代理对象调用目标对象方法完成计算，并在前后打印日志
		calculator.add(1, 2);
		calculator.subtract(2, 1);
	}
}

public class ProxyTest {
	public static void main(String[] args) throws Throwable {
		//Calculator的类加载器
		Class calculatorProxyClazz = Proxy.getProxyClass(Calculator.class.getClassLoader(), Calculator.class);
		//得到有参构造器
        Constructor constructor =  calculatorProxyClazz.getConstructor(InvocationHandler.class);
        //反射创建代理实例
        Calculator CalculatorProxyImpl = (Calculator)constructor.newInstance(new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method, method, Object[] args) throws Exception {
                //手动new一个目标对象
                CalculatorImpl calculatorImpl = new CalculatorImpl();
                //反射执行目标对象的方法
                Object result = method.invoke(calculatorImpl, args);
                //返回目标对象执行结果
                return result;
            }
        })
		CalculatorProxyImpl.add(1, 2);
		
	}
}

public class ProxyTest {
	public static void main(String[] args) throws Throwable {
        //传入目标对象
        CalculatorImpl target = new CalculatorImpl();
        //根据它实现的接口生成代理对象， 代理对象调用目标对象方法
		Calculator calculatorProxy = (Calculator)getProxy(target);
        calculatorProxy.add(1, 2);
        calculatorProxy.substract(2, 1);
    }

    private static Object getProxy(final Object target) throws Exception {
		Class ProxyClazz = Proxy.getProxyClass(target.getclass().getClassLoader(), target.getclass().getInterfaces());
		//得到有参构造器
        Constructor constructor =  ProxyClazz.getConstructor(InvocationHandler.class);
        //反射创建代理实例
        Object proxy = constructor.newInstance(new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method, method, Object[] args) throws Exception {
                System.out.println(method.getName() + "方法开始执行。。");
                Object result = method.invoke(target, args);
                //反射执行目标对象的方法
                
                return result;
            }
        });
		return proxy;
		
	}
}

public class ProxyTest {
	public static void main(String[] args) throws Throwable {
        //传入目标对象
        CalculatorImpl target = new CalculatorImpl();
        //根据它实现的接口生成代理对象， 代理对象调用目标对象方法
		Calculator calculatorProxy = (Calculator)getProxy(target);
        calculatorProxy.add(1, 2);
        calculatorProxy.substract(2, 1);
    }

    private static Object getProxy(final Object target) throws Exception {
		Object proxy = Proxy.newProxyInstance(target.getclass().getClassLoader(), target.getclass().getInterfaces(),
		new InvocationHandler() {
            
            public Object invoke(Object proxy, Method, method, Object[] args) throws Exception {
                System.out.println(method.getName() + "方法开始执行。。");
                Object result = method.invoke(target, args);
                //反射执行目标对象的方法
                
                return result;
            }
        }
        );
		return proxy;
		
	}
}

UserService {
    public void test() {
        //开启事务
        userDao.add();
    }
}

BrandService {
    public void test() {
        //开启事务
        brandDao.add();
    }
}

CategoryService {
    public void test() {
        //开启事务
        categoryDao.add();
    }
}

|代理工厂| 
  代理对象 {
    //1.开启事务
    txManager.beginTransaction(); //+2
    //2.执行事务
    rtValue = method.invoke(target, args) --> 调用代理对象同名方法+3 +5
       //3.提交事务
    txManager.commit(); //+6
    //3.返回结果
    return rtValue; //+7
}

UserService {
    public void test() { //+4
        //开启事务
        userDao.add();
    }
}

package com.demo.myaopframework.utils;

import org.apache.commons.dbcp.BasicDataSource;

import java.sql.Connection;

/**
 * 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定
 */
public class ConnectionUtils {

    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

    private static BasicDataSource dataSource = new BasicDataSource();

    //静态代码块,设置连接数据库的参数
    static{
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
    }


    /**
     * 获取当前线程上的连接
     * @return
     */
    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();
    }
}

package com.demo.myaopframework.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();
        }
    }
}

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

public interface UserService {
	void getUser();
}

 
public class UserServiceImpl implements UserService {
	@Override
	public void getUser() {
		System.out.println("service执行...");
	}
}

public class BeanFactory {

	public Object getBean(String name) throws Exception {
		//得到目标类的Class对象
		Class<?> clazz = Class.forName(name);
		//得到目标对象
		Object bean = clazz.newInstance();
		//得到目标类上的@MyTransactional注解
		MyTransactional myTransactional = clazz.getAnnotation(MyTransactional.class);
		//如果打了@MyTransactional注解，返回代理对象，否则返回目标对象
		if (null != myTransactional) {
			ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
			TransactionManager txManager = new TransactionManager();
			txManager.setConnectionUtils(new ConnectionUtils());
			//装配通知和目标对象
			proxyFactoryBean.setTxManager(txManager);
			proxyFactoryBean.setTarget(bean);
			Object proxyBean = proxyFactoryBean.getProxy();
			//返回代理对象
			return proxyBean;
		}
		//返回目标对象
		return bean;
	}
}

public class ProxyFactoryBean {
	//通知
	private TransactionManager txManager;
	//目标对象
	private Object target;

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

	public void setTarget(Object target) {
		this.target = target;
	}

	//传入目标对象target，为它装配好通知，返回代理对象
	public Object getProxy() {
		Object proxy = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),/*1.类加载器*/
				target.getClass().getInterfaces(), /*2.目标对象实现的接口*/
				new InvocationHandler() {/*3.InvocationHandler*/
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						try {
							//1.开启事务
							txManager.beginTransaction();
							//2.执行操作
							Object retVal = method.invoke(target, args);
							//3.提交事务
							txManager.commit();
							//4.返回结果
							return retVal;
						} catch (Exception e) {
							//5.回滚事务
							txManager.rollback();
							throw new RuntimeException(e);
						} finally {
							//6.释放连接
							txManager.release();
						}

					}
				}
		);
		return proxy;
	}

}

BeanFactory beanFactory = new BeanFactory();
try {
    Object bean = beanFactory.getBean("com.demo.mya.service.UserServiceImpl");
    Sout(bean.getClass().getName());
}

public class Basic {
    @Test
    public void testJdbc() throws SQLException, ClassNotFoundException {
        // 1.注册驱动
        Class.forName("com.mysql.jdbc.Driver");

        // 2.建立练连接
        String url = "jdbc:mysql://192.168.56.10:3306/test";
        String user = "root";
        String password = "root";
        Connection conn = DriverManager.getConnection(url, user, password);

        // 3. 创建sql模板
        String sql = "select * from t_user where id = ?";
        PreparedStatement preparedStatement = conn.preparedStatement(sql);

        // 4. 设置模板参考
        preparedStatement.setInt(1, 5);

        // 5. 执行语句
        ResultSet rs = preparedStatement.executeQuery();

        // 6. 处理结果
        while (rs.next()) {
            System.out.println(rs.getObject(1) + "\t" + rs.getObject(2) + "\t" + rs.getObject(3) + "\t" + rs.getObject(4))；
            
        }

        // 7. 释放资源
        rs.close();
        preparedStement.close();
        conn.close();

    }
}

public class Basic {
    // 抛异常
    @Test
    public void testJdbc() throws SQLException {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            // 1. 获得连接
            conn = JdbcUtils.getConnection();
            String sql = "select * from t_user where id = ?";
            ps = conn.preparedStatement(sql);

            // 4. 设置模板参考
            ps.setInt(1, 5);

            // 5. 执行语句
            rs = ps.executeQuery();

            // 6. 处理结果
            while (rs.next()) {
                System.out.println(rs.getObject(1) + "\t" + rs.getObject(2) + "\t" + rs.getObject(3) + "\t" + rs.getObject(4))；
                
            }
        } finally {
            JdbcUtils.free(rs, ps, conn);
        }
    }
}

public class JdbcUtils {

        private static Properties pros = null;

        // 只在JdbcUtils类都加载执行一次
        static {
            // 1. 给pros进行初始化，加载jdbc.properties文件到props对象中
            try {
                InputStream in = JdbcUtils.class.getClassLoader()
                                .getResourceAsStream("jdbc.properties");
                props = new Properties();
                props.load(in);  
            } catch (IOException e) {
                throw new RuntimeException(e);
            }

            //加载驱动类
            try {
                Class.forName(props.getProperty("driver"));
            } catch (ClassNotFoundException e) {
                throw new RuntimeException(e);
            }
        }

        // 获取连接
        public static Connection getConnection() throws SQLException {
            // 得到Connection
            return DriverManager.getConnection(props.getProperty("url"),
                            props.getProperty("username"),
                            props.getProperty("password"));
        }

        // 释放连接
        public static void free (ResultSet rs, Statement st, Connection conn) {
            try {
                if (rs != null) {
                    rs.close();
                }
            } catch (SQLException e) {
                e.printStackTrack();
            } finally {
                try {
                    if (st != null) {
                        st.close();
                    }
                } catch (SQLException e) {
                    e.printStackTrack();
                } finally {
				if (conn != null)
					try {
						conn.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
            }
        }
    }
}