當我們對數據庫進行操作時，通常會定義一個接口類，然後定義很多的實現類來實現這個接口的所有方法，這樣就會產生很多的實現類出來，增加了代碼的冗余度，所以我們可以通過

動態代理模式來動態生成實現類來代替所有的實現類，再通過一個工廠來生成實現類，這樣就大大減小的代碼的重復性了，增強了靈活性！

實現步驟：

1.數據庫接口類

package mybatis.dao;



import mybatis.entity.Users;

import java.util.List;
import java.util.Map;

/**
 * @Author lance
 * */
public interface
 
 UserDaoInf {
    /**
     * 添加用戶
     */
     void saveUser(Users users);

    /**
     * 修改用戶
     */
     void updateUser(Users users);

    /**
     * 刪除用戶
     */
    void deleteUser(String uid);

    /**
     * 根據ID查詢某條用戶數據
     */
    Users findUsersById(String uid);

    /**
     * 查詢所有的用戶信息，保存在一個集合中
     
 
*/
    List<Users> findAll();
    /**
     * 統計查詢
     */
    int userCount();
    /**
     * 模糊查詢
     */
    List<Users> likeUsers(String name);
    /**
     * 查詢所有的用戶信息
     */
    List<Users> findAll2();
    /**
     * 查詢單條的用戶信息
     */
    Map<String ,Object> findUserMap(String uid);
    
 
/**
     * 查詢多條的用戶信息
     */
    List<Map<String,Object>> findUserListMap();
}

2.動態代理實現類

package mybatis.dao.proxy;


import mybatis.tools.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;

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

/**
 * 描述:
 * 動態代理實現類
 *
 * @author lance
 * @create 2018-10-15 9:33
 */
public class MethodProxy implements InvocationHandler{

    private Class<?> infClass;

    public MethodProxy(Class<?> infClass){
        this.infClass = infClass;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        SqlSession session = MyBatisUtil.getSqlSession();
            try{
               Object mapper = session.getMapper(infClass);
               Object returnValue = method.invoke(mapper,args);
               session.commit();
               return returnValue;
            }catch (Exception e){
                session.rollback();
                throw new RuntimeException(e.getMessage());
            }finally {
                session.close();
            }
    }
}

3.代理工廠

package mybatis.dao.proxy;

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

/**
 * 描述:
 * 代理對象工廠
 * @author lance
 * @create 2018-10-15 11:42
 */
public class MethodProxyFactory {

    public static <T> T createProxy(Class<T> infClass){
        //調用回調處理器
        InvocationHandler handler = new MethodProxy(infClass);
        return (T)Proxy.newProxyInstance(infClass.getClassLoader(),new Class[]{infClass},handler);
    }

}

4.測試

import mybatis.dao.UserDaoInf;
import mybatis.dao.proxy.MethodProxyFactory;
import mybatis.entity.Users;
import org.junit.Test;

import java.util.List;


/**
 * 描述:
 *
 * @author lance
 * @create 2018-09-10 15:15
 */
public class UserDaoImplTest {

    @Test
    public void testFindUserById2(){
        //動態生成代理對象
        UserDaoInf dao = MethodProxyFactory.createProxy(UserDaoInf.class);
        Users user = dao.findUsersById("1001");
        System.out.println(user.getUid());
        System.out.println(user.getUserName());

        List<Users> list = dao.findAll();
        for (Users users : list) {
            System.out.println(users.getUid());
        }
    }

}

5.效果圖

動態實現類（對數據庫的增刪改查）