代码的重构实例(Java JDBC)学习

代码的重构

在我平时的代码开发中,各个部分的功能确实能够实现,但是缺少重构,代码显得十分的臃肿,扩展性差、不易于后续的维护。
下面就简单的Java JDBC的数据访问操作,进行重构的尝试。
详细代码已经托管在github平台:github代码托管链接
如果能给个小星星,将是对我莫大的鼓励。。。。

原始代码

本人用MySQL作为数据,并在springmodel数据库中创建一张名为t_student的数据表。

package Test.StudentService;

import Test.Entity.student;
import Test.Utils.DbUtil;

import java.sql.*;

/**
 * @Classname stuService
 * @Description TODO
 * @Date 2020/3/24 18:30
 * @Created by ASUS
 */
public class stuService implements IService{
    /**
     *功能描述:将传入的学生信息加入到数据库中
     *@param stu the student need to be saved.
     *Author Jason
     *Date 2020-03-24 18:33
     */
    @Override
    public void save_student(student stu){
        String sql = "INSERT INTO t_student(name,age) VALUES(?,?)";
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        int age = stu.getStu_Age();
        String name = stu.getStu_Name();
        try {
            Class.forName("com.mysql.jdbc.Driver");//注册驱动
            connection = DriverManager.getConnection//获取连接
                    ("jdbc:mysql://localhost:3306/springmodel?serverTimezone=UTC&characterEncoding=utf8","root","");
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setObject(1,name);
            preparedStatement.setObject(2,age);
            preparedStatement.execute();//执行SQL语句
            
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            try{
            if(preparedStatement != null){
                preparedStatement.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try{
                if(connection != null){
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        }
    }



    /**
     *功能描述:根据id值在数据库中检索并删除数据
     *@param id the id of the student that need to be deleted.
     *Author Jason
     *Date 2020-03-24 18:36
     */
    @Override
    public void delete_stu_byId(int id){
        String sql = "DELETE FROM t_student WHERE age=?";
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");//注册驱动
            connection = DriverManager.getConnection//获取连接
                    ("jdbc:mysql://localhost:3306/springmodel?serverTimezone=UTC&characterEncoding=utf8","root","");
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setObject(1,id);
            preparedStatement.execute();//执行SQL语句

        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }finally {
            try{
            if(preparedStatement != null){
                preparedStatement.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try{
                if(connection != null){
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        }

    }
    /**
     *功能描述:更新学生的信息数据
     *@param stu the student that need to be pull into database.
     *Author Jason
     *Date 2020-03-24 18:37
     */
    @Override
    public void update_stu(student stu){
        String sql = "UPDATE t_student SET name=? WHERE age=?";
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");//注册驱动
            connection = DriverManager.getConnection//获取连接
                    ("jdbc:mysql://localhost:3306/springmodel?serverTimezone=UTC&characterEncoding=utf8","root","");
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setObject(1,stu.getStu_Name());
            preparedStatement.setObject(2,stu.getStu_Age());
            preparedStatement.execute();//执行SQL语句

        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }finally {
            try{
            if(preparedStatement != null){
                preparedStatement.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try{
                if(connection != null){
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        }
    }


}

重构优化过程

可以看出仅仅是简单的增删改的操作,代码行数100+,臃肿得不要太厉害。
其实我们细看代码,可以发现其中有很多的代码是可以抽取出来的,提高程序的复用率。
在每个方法中,都有重复的注册数据库驱动,获取数据库连接的操作代码,相似度很高,于是可以将其抽取到一个工具类DbUtil中。同时观察代码:

Class.forName("com.mysql.jdbc.Driver");//注册驱动
            connection = DriverManager.getConnection//获取连接
                    ("jdbc:mysql://localhost:3306/springmodel?serverTimezone=UTC&characterEncoding=utf8","root","");

得出:有关数据连接的各种数据如:端口localhost:3306,数据库名称:springmodel,数据库的用户名和密码等都显式的出现在代码中,不符合软件架构设计的开闭原则(Open-Closed Pinciple,OCP)(指的是一个软件实体,如类、函数和模块等,对扩展开放,对修改关闭。)在需要对使用的数据名称改变时,就需要对源代码修改,可维护性低;另外,数据库的用户名和密码直接出现在代码中,不仅对后期的账户和密码的维护不利,还存在着一定的隐患。
于是可以将url,name,password等其他信息写入到一个mysql.properties文件中,程序通过读取配置信息,来获得建立连接需要的信息,不仅提高了代码的可扩展性,还一定程度上降低了安全隐患。同样对于不同的SQL语句也进行上述的设计,可以方便后续程序的维护。根据以上思考,建立工具类:


/**
 * @Classname DbUtil
 * @Description TODO
 * @Date 2020/3/25 18:22
 * @Created by ASUS
 */
public class DbUtil implements Serializable {
    private static Properties properties = null;

    static {//静态的代码块,一旦产生该类的对象,自动执行该代码块
        /*使用static 静态初始化代码块时候注意应用
         *try{....}catch(Exception e){...},
         *否则会发生类初始化异常*/
        try{
//            ClassLoader loader = Thread.currentThread().getContextClassLoader();
//            InputStream is = loader.getResourceAsStream("");
            InputStream is = new FileInputStream(new File("config/mysql.properties"));
            properties = new Properties();
            properties.load(is);        //加载数据库的properties文件
            //加载数据库注册驱动
            Class.forName(properties.getProperty("driver"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     *功能描述:返回数据库的连接connection
     * 声明为类的静态方法
     */
    public static Connection getConnect(){
        Connection connection = null;
        String url = properties.getProperty("url");
        String name = properties.getProperty("user");
        String pwd = properties.getProperty("password");
        try {
            connection = DriverManager.getConnection(url,name,pwd);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return  connection;
    }
  }

mysql.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/springmodel?serverTimezone=UTC&characterEncoding=utf8
user=root
password=
serverIP=127.0.0.1

SQL.properties

INSERT=INSERT INTO t_student(name,age) VALUES (?,?)
UPDATE=UPDATE t_student SET name=? WHERE age=?
DELETE=DELETE FROM t_student WHERE age=?
QUERY_AGE=SELECT * FROM t_student WHERE age=?
QUERY_ALL=SELECT * FROM t_student

然后在调用的方法中直接调用getConnect()方法即可得到与数据库的连接。程序的可读性也得到提高。到这里似乎已经完成了优化,但仔细观察,代码中除去已经优化的建立连接的部分,仍然有很多的代码类似,比如在进行数据库操作之后,关闭相应的连接,释放资源的代码即可以抽出到工具类中。在DML操作中,除了SQL语句的设置不同,其他部分基本一致,可以进行相同部分抽取,不同部分以参数的形式传入。这些抽取可以构建一个模板类
JDBCTemplate.java

/**
 * @Classname JDBCtemplate
 * @Description TODO
 * @Date 2020/3/26 9:38
 * @Created by ASUS
 */
public class JDBCtemplate {
    //Query template统一查询模版(DQL),借助泛型方便功能的扩展
    @Nullable
    public static <E> E Query(String sql, IRowMapper<E> mapper, Object...params){
//        List<student> studentList = new ArrayList<>();
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet rs = null;
        try {
            connection = DbUtil.getConnect();
            preparedStatement = connection.prepareStatement(sql);
            setPreparedStatement(preparedStatement,params);
            rs = preparedStatement.executeQuery();
            return mapper.mapping(rs);//处理结果集,由实现类自己完成
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DbUtil.close(rs,preparedStatement,connection);
        }
        return null;
    }
    //DML
    public static void Manipulation(String sql,Object...params){
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = DbUtil.getConnect();
            preparedStatement = connection.prepareStatement(sql);
            setPreparedStatement(preparedStatement,params);//设置值
            preparedStatement.execute();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {//释放资源
            DbUtil.close(null,preparedStatement,connection);
        }
    }
    //处理preparedStatement,设置值
    private static void setPreparedStatement(PreparedStatement preparedStatement,Object... params) throws SQLException {
        for(int i = 0; i < params.length;i++){
            preparedStatement.setObject(i+1,params[i]);
        }
    }
}

对于模板类的设计,充分的考虑到可扩展性,如果只是对t_stuent的数据和类student的操作,不做其他任何的设计就已经可以了,但是如果以后面对业务的扩展或者更改,就显得有点力不从心了。其实针对不同的表的返回集,应该有不同的操作,而怎样操作返回集,不是模板类所关心的内容,而根据单一职责原则Simple Responsibility Pinciple,SRP),解耦合,于是创建了带泛型的一个接口:IRowMapper

/**
 * @Classname IRowMapper
 * @Description TODO
 * @Date 2020/3/26 13:51
 * @Created by ASUS
 */
public interface IRowMapper<E> {
    /**
     *功能描述:根据结果集的类型进行对应处理
     *@param resultSet 待处理的结果集
     *Author Jason
     *Date 2020-03-26 13:52
     */
    E mapping(ResultSet resultSet)throws Exception;
}

对从数据库中查询得到的返回集ResultSet由其具体的实现类完成,这样一来,程序就不止是能够查询t_student的数据,还能查如t__teacher表中的数据,扩展性得到提高。
好了,到了这里,这部分的代码重构应该就差不多了。
下面看看优化后的代码:

优化后的代码

/**
 * @Classname stuServicee_2
 * @Description TODO
 * @Date 2020/3/26 9:35
 * @Created by ASUS
 */
public class stuService_2 implements IService {
    //各种在SQL语句存储在config/SQL.properties文件中
    private static final String INSERT = "INSERT";
    private static final String UPDATE = "UPDATE";
    private static final String DELETE = "DELETE";
    private static final String QUERY_AGE = "QUERY_AGE";
    private static final String QUERY_ALL = "QUERY_ALL";
    @Override
    public void save_student(student stu) {
        String sql = DbUtil.getSQL(INSERT);
        JDBCtemplate.Manipulation(sql,stu.getStu_Name(),stu.getStu_Age());
    }
    @Override
    public void delete_stu_byId(int id) {
        String sql = DbUtil.getSQL(DELETE);
        JDBCtemplate.Manipulation(sql,id);
    }
    @Override
    public void update_stu(student stu) {
        String sql = DbUtil.getSQL(UPDATE);
        JDBCtemplate.Manipulation(sql,stu.getStu_Name(),stu.getStu_Age());
    }
    //根据年龄(当前认为的主键,实际数据库中没有设置主键)查询
    public student Query_stu(int age){
        String sql = DbUtil.getSQL(QUERY_AGE);
        List<student> students = JDBCtemplate.Query(sql, new StudentRowMapper(),age);
        assert students != null;
        return students.size() > 0 ? students.get(0) : null;
    }
    //以List集合的形式,返回所有表中的数据
    public List<student> Query_stu(){
        String sql = DbUtil.getSQL(QUERY_ALL);
        return JDBCtemplate.Query(sql, new StudentRowMapper());
    }
    static class StudentRowMapper implements IRowMapper<List<student>>{
        /**
         * 功能描述:处理学生结果集数据
         * @param resultSet 待处理的结果集
         * Author Jason
         */
        @Override
        public List<student> mapping(ResultSet resultSet) throws Exception {
            List<student> students = new ArrayList<>();
            while (resultSet.next()){
                students.add(new student(resultSet.getInt("age"),resultSet.getString("name")));
            }
            return students;
        }
    }

}

与之前的代码相比,不仅是代码量得到很大程度的精简,更重要的是代码的可读性提高,可扩展性得到升,后期的维护也变得更加方便。
在这里我只是简单地进行了一小部分的代码的重构,以后随着功能的复杂程度不断的加大,程序之间的关系就会变得十分的复杂,而重构就可以将海量的代码按照逻辑有效的设计与实现,在项目的后期维护和扩展时都有很重要的作用。

发布了7 篇原创文章 · 获赞 1 · 访问量 216
App 阅读领勋章
微信扫码 下载APP
阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 数字20 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览