[Java知识库]策略模式+单例模式+工厂模式 实现对 针对于 MyBaits 增删改查功能的二次封装

MyBaits 针对于增删改查功能的二次封装

在使用传统的Mybaits实现JDBC时候，我们会发现增删改查的代码在有些方面不尽相同，我在这里进行进行了一个简单的二次封装

• 主要实现思路: 使用策略+单例+工厂模式进行代码逻辑封装

1.封装一个针对于处理业务逻辑的接口类

• 完成增加，删除，修改操作时候返回的都是int类型的返回值

• 完成查询操作的时候,Mybaits是根据Example去生成sql语句，然后去运行Example生成的sql语句

总结：

• 我们可以把返回类型设置成R类型的数据，把形参的类型设置为T数据类型

• 我们这里使用的泛化变成

代码如下

package until.factory;

/**
 * @param <T> info type
 * @param <R> return type
 */
public interface InterfaceExample<T,R> {
    /**
     * update / insert/ delete/ select
     * @param info R info
     * @return T info
     * @throws Exception throws Exception
     */
    R doAnything(T info) throws Exception;
}

2.分别封装针对于两种业务逻辑的处理抽象类

• 增加、删除，修改的业务逻辑相较于花样查询的操作不一样的是

  • 后者会涉及到分页的问题，而前者不会

代码如下:

• 针对于花样查询的操作的抽象类

package until.factory;

import com.github.pagehelper.PageHelper;
import until.StaticMessage;

import java.util.HashMap;
import java.util.Map;

/**
 * (E)object = select * form (T)info where ((T)?.? = (T)info.?,.....) [or ((T)?.?=(T)info.?,......)] [limit (?,?)/limit(?)];
 *
 * @param <T> info type
 * @param <R> mapper factory type
 * @param <V> action type
 * @param <E> return object
 */
public abstract class AbstractSelectFactory<T,R,V,E>{
    protected Map<V, InterfaceExample<T,R>> map =new HashMap<>();

    /**
     * @param pageSize page-size
     * @param pageNumber page-number
     */
    public AbstractSelectFactory(int pageSize, int pageNumber) {
        PageHelper.startPage(pageNumber,pageSize);
    }

    /**
     * init mapper
     */
    protected abstract void init();

    /**
     * get mapper info
     * @param info T info
     * @return get mapper info
     * @throws Exception Exception message
     */
    protected R goAction(V action,T info) throws Exception {
        InterfaceExample<T,R> mapper=map.get(action);
        if (mapper!=null) {
            return mapper.doAnything(info);
        }else{
            throw new RuntimeException(StaticMessage.UserExamination.USER_ACTION_NOT_FOUND);
        }
    }

    /**
     * E object = select * form ? where (?.?=info.?,.....) [or (?.?=info.?,......)] [limit (?,?)/limit(?)];
     * @param action action
     * @param info info
     * @return return the list for models
     */
    protected abstract E doAnything(V action,T info) throws Exception;
}

• 针对于增加，修改，删除的操作的抽象类

package until.factory;

import until.StaticMessage;

import java.util.HashMap;
import java.util.Map;

/**
 * @param <T> info type
 * @param <R> successfully_count = insert/update/delete
 * @param <V> mapper key type
 */
public abstract class AbstractDoFactory<T,R,V>{

    protected Map<V, InterfaceExample<T,R>> map =new HashMap<>();

    /**
     * init mapper
     */
    protected abstract void init();


    /**
     * - insert/update/delete factory something
     * @param action action name
     * @param info T info
     * @return is successfully
     * @throws Exception Exception
     */
    public R goAction(V action, T info) throws Exception {
        InterfaceExample<T,R> mapper=map.get(action);
        R getSuccessResult;
        if (mapper != null) {
            try {getSuccessResult = mapper.doAnything(info);
            } catch (Exception e) {throw new Exception(e.getMessage());}
        } else {
            throw new RuntimeException(StaticMessage.UserExamination.USER_ACTION_NOT_FOUND);
        }
        return getSuccessResult;
    }

}

3.封装不同业务逻辑的动作参数

package until;

public class ActionName {
    public static class UserDoFactoryName{
        public static final String CREATE_USER = "create-user";
        public static final String USER_LOGIN = "user-login";
    }
}

4.封装针对于一张表的代码逻辑

• 针对以增加，修改，删除操作并且针对于用户表的业务逻辑

注意: 我这里是封装成了单例模式的实现

package server.factory;


import com.project.blog.entity.UserModels;
import server.example.UserInsert;
import until.ActionName;
import until.factory.AbstractDoFactory;

public class UserDoFactory extends AbstractDoFactory<UserModels,Integer,String> {
    // 单例模式的实现代码实现逻辑
    private static UserDoFactory instance;
    private  UserDoFactory() {}

    public static UserDoFactory getInstance() {
        if (instance == null) {
            try {
                instance = new UserDoFactory();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return instance;
    }
    // 代码逻辑结束，以下为核心代码逻辑
    @Override
    protected void init() {// 下面是我写的一个针对于用户注册的，使用时候特别注意自己的业务逻辑
        map.put(ActionName.UserDoFactoryName.CREATE_USER,new UserInsert());
    }

}

• 针对于花样查询的针对于用户表的抽象类

注意: 我这里是封装成了单例模式的实现

package server.factory;

import com.github.pagehelper.PageInfo;
import com.project.blog.entity.UserModels;
import com.project.blog.entity.UserModelsExample;
import com.project.blog.mapper.UserModelsMapper;
import org.apache.ibatis.session.SqlSession;
import server.example.UserLogin;
import until.ActionName;
import until.MybatisClass;
import until.factory.AbstractSelectFactory;

import java.util.List;

public class UserSelectFactory extends AbstractSelectFactory<UserModels, UserModelsExample, String, PageInfo<UserModels>> {
    // 单例模式的实现代码实现逻辑-参数初始化
    private static UserSelectFactory userSelectFactory;

    /**
     * 针对于分页的代码必要，由抽象类继承。
     * @param pageSize   page-size
     * @param pageNumber page-number
     */
    private UserSelectFactory(int pageSize, int pageNumber) {
        super(pageSize, pageNumber);
    }

    // 单例模式的实现代码实现逻辑-实例化参数
    public static UserSelectFactory getInstance(int pageSize, int pageNumber) {
        if (userSelectFactory == null) {
            try {
                userSelectFactory = new UserSelectFactory(pageSize,pageNumber);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return userSelectFactory;
    }

    // 策略模式:代码初始化map 的参数
    @Override
    public void init() {
        // 下面是我的业务逻辑，请注意自己的业务逻辑类
        map.put(ActionName.UserDoFactoryName.USER_LOGIN,new UserLogin());
    }

    // 核心代码实现-实现查询并且把查询结果返回
    @Override
    public PageInfo<UserModels> doAnything(String action, UserModels info) throws Exception {
        PageInfo<UserModels> userModels=new PageInfo<>();
        SqlSession sqlSession = MybatisClass.getSqlSession();
        UserModelsMapper usersMapper = sqlSession.getMapper(UserModelsMapper.class);
        UserModelsExample userModelsExample =goAction(action,info);
        try {
            List<UserModels> userModelList=usersMapper.selectByExample(userModelsExample);
            userModels=new PageInfo<>(userModelList);
        } finally {
            sqlSession.close();
        }
        return userModels;
    }
}

5.实例代码逻辑实体实现类

注册的代码逻辑

package server.example;

import com.github.pagehelper.PageInfo;
import com.project.blog.entity.UserModels;
import com.project.blog.mapper.UserModelsMapper;
import org.apache.ibatis.session.SqlSession;
import until.MybatisClass;
import until.factory.InterfaceExample;

public class UserInsert implements InterfaceExample<UserModels, Integer> {
    /**
     * @param info R info
     * @return insert info userModels(info)
     * @throws Exception sqlException
     */
    @Override
    public Integer doAnything(UserModels info) throws Exception {
        int success = -1;
        PageInfo<UserModels> userModels=null;
        SqlSession sqlSession = MybatisClass.getSqlSession();
        UserModelsMapper usersMapper = sqlSession.getMapper(UserModelsMapper.class);
        try {
            success=usersMapper.insert(info);
        } finally {sqlSession.close();}
        return success;
    }
}

登录的代码逻辑

package server.example;


import com.project.blog.entity.UserModels;
import com.project.blog.entity.UserModelsExample;
import until.factory.InterfaceExample;

public class UserLogin implements InterfaceExample<UserModels, UserModelsExample> {

    @Override
    public UserModelsExample doAnything(UserModels info) throws Exception {
        UserModelsExample userModelsExample =new UserModelsExample();
        userModelsExample.createCriteria().andUserNameEqualTo(info.getUserName()).andUserPasswordEqualTo(info.getUserPassword());
        userModelsExample.setOrderByClause("user_id");
        return userModelsExample;
    }
}

6.代码调用实例

下面的代码是实现用户登录成功后返回 一个新的session值，否则返回NULL

package server.server;


import com.project.blog.entity.UserModels;
import server.factory.UserSelectFactory;
import until.ActionName;
import until.StringUtils;

import javax.servlet.http.HttpServletRequest;
import java.util.List;
import java.util.UUID;

public class UserLoginServer {
    private static UserModels userModels;
    private static UserLoginServer userLoginServer;

    private UserLoginServer(){
         userLoginServer=new UserLoginServer();
         userModels=new UserModels();
    }

    public static UserLoginServer getInstance() {
        return userLoginServer;
    }

    public String login(HttpServletRequest request) throws Exception {
        String usernames = request.getParameter("user-name");
        String password = request.getParameter("password");
        String pageSize = request.getParameter("page-size");
        String pageNumber = request.getParameter("page-number");
        if (StringUtils.isEmpty(usernames) || StringUtils.isEmpty(password)|| StringUtils.isEmpty(pageSize) || StringUtils.isEmpty(pageNumber)) {
            return null;
        }else{
            userModels.setUserName(usernames);
            userModels.setUserPassword(password);
        }

        int getPageNumber = Integer.parseInt(pageNumber);
        int getPageSize = Integer.parseInt(pageSize);

        UserSelectFactory userSelectFactory =UserSelectFactory.getInstance(getPageNumber,getPageSize);
        userSelectFactory.init();
        List<UserModels> users =userSelectFactory.doAnything(ActionName.UserDoFactoryName.USER_LOGIN,userModels).getList();
        return users.size()==1? String.valueOf(UUID.randomUUID()):null;
    }
}

这个是封装好的String工具类

package until;

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;

public class StringUtils {

    public static boolean isEmpty(String str){
        return str == null || str.trim().equals("");
    }


    public static String cutString(String str,int begin ,int  end){
        if(str.length() < end  || str.length()< begin) return str;
        return str.substring(begin,end);
    }


    //解码 解决在URL传中文值出现的乱码问题
    public static String pareCode(String str) throws UnsupportedEncodingException{
        return new String(str.getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8);
    }

}

封装好的返回值如下

package until;

public class StaticMessage {
    public static final class UserExamination{
        //用户注册失败，用户的用户名重复，请重新设置
        public static final String USER_CREATED_FAITHFULLY = "User registration failed. The user name is duplicate. Please reset";
        //非法动作，请重新选择
        public static final String USER_ACTION_NOT_FOUND = "Illegal action, please reselect";
    }
}

下面是返回Json数据的数据封装包装类

package until;

import javax.servlet.http.HttpServletResponse;

public class RestfulUtil{
    //两个返回的状态
    private static final int SUCCESS = HttpServletResponse.SC_OK;
    private static final int Fail = HttpServletResponse.SC_GONE;
    //成功与失败时的消息
    private static final String msg1 = "successful";
    private static final String msg2 = "succeed";

    public static class Resultant {
        private int flagCode;  //response-code
        private String  message;  //response-message
        private Object   data;    // response-data

        public int getFlag() {
            return flagCode;
        }

        public void setFlag(int flag) {
            this.flagCode = flag;
        }

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }

        public Object getData() {
            return data;
        }

        public void setData(Object data) {
            this.data = data;
        }

        @Override
        public String toString() {
            return "{" +
                    "flagCode=" + flagCode +
                    ", message='" + message + '\'' +
                    ", data=" + data +
                    '}';
        }
    }

    private static Resultant resultant;

    //成功
    public static Resultant getSuccessResult() {
        resultant = new Resultant();
        resultant.setMessage(msg1);
        resultant.setFlag(SUCCESS);
        return resultant;

    }

    //成功，附带自定义数据
    public static Resultant getSuccessResult(String message) {
        resultant = new Resultant();
        resultant.setMessage(message);
        resultant.setFlag(SUCCESS);
        return resultant;

    }

    //成功，附带额外数据
    public static Resultant getSuccessResult(Object data) {
        resultant = new Resultant();
        resultant.setData(data);
        resultant.setMessage(msg1);
        resultant.setFlag(SUCCESS);
        return resultant;
    }

    //成功，自定义消息及数据
    public static Resultant getSuccessResult(String message,Object data) {
        resultant = new Resultant();
        resultant.setData(data);
        resultant.setMessage(message);
        resultant.setFlag(SUCCESS);
        return resultant;

    }

    //失败
    public static Resultant getFailResult() {
        resultant = new Resultant();
        resultant.setMessage(msg2);
        resultant.setFlag(Fail);
        return resultant;
    }

    //失败，附带消息
    public static Resultant getFailResult(String message) {
        resultant = new Resultant();
        resultant.setMessage(message);
        resultant.setFlag(Fail);
        return resultant;

    }

    //失败，自定义消息及数据
    public static Resultant getFailResult(String message, Object data) {
        resultant = new Resultant();
        resultant.setData(data);
        resultant.setMessage(message);
        resultant.setFlag(Fail);
        return resultant;

    }

    //自定义创建
    public static Resultant getFreeResult(int code, String message, Object data) {
        resultant = new Resultant();
        resultant.setData(data);
        resultant.setMessage(message);
        resultant.setFlag(code);
        return resultant;
    }
}

下面是附赠的用户注册的调用方式

  UserDoFactory userDoFactory = UserDoFactory.getInstance();
        userDoFactory.init();
        UserModels userModel = new UserModels();
        userModel.setUserName("texs");
        userModel.setUserPassword("texts");
        try {
            System.out.println(userDoFactory.goAction(ActionName.UserDoFactoryName.CREATE_USER,userModel));
        } catch (Exception e) {
            e.printStackTrace();
        }