mysql---MVC+JDBC封装实例

MVC

model 模型 ，系统内对象的类型
view 视图，系统展示界面
controller 控制器，统一各部，让系统运行起来
dao： data access object 数据访问处理

数据库

这里仅仅是为了方便，所有数据类型为字符串，但是在实际应用中是不合适的！

model包

学生类型

package com.situ.model;

import java.sql.Date;
import java.time.LocalDate;

/**
 * @author : 一只小海猪
 * @date : 17:32 2021/11/10
 */
public class Student {
    private String id ;
    private String name;
    private String sex;
    private String classname;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getClassname() {
        return classname;
    }

    public void setClassname(String classname) {
        this.classname = classname;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", classname='" + classname + '\'' +
                '}';
    }
}

常量类，放一些常用的常量

package com.situ.model;

/**
 * @author : 一只小海猪
 * @date : 20:43 2021/11/11
 */
public class GlobalConstants {
    public static final String url = "jdbc:mysql://localhost:3306/student?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false";
    public static final String user = "root";
    public static final String password = "123456";
}

view包

即向用户互动，展示的类

package com.situ.view;

import com.situ.model.Student;

import java.util.List;
import java.util.Scanner;

/**
 * @author : 一只小海猪
 * @date : 20:49 2021/11/11
 */
public class StudentView {
    private Scanner sc;
    //主菜单
    public String showMenu(){

        System.out.println("==============================================");
        System.out.println("1.添加学生 2.修改学生 3.删除学生 4.显示全部学生 5.退出");
        System.out.println("==============================================");
            try {
                System.out.println("请输入操作");
                sc = new Scanner(System.in);
                return sc.next();
            }catch (Exception e){
                System.out.println("输入操作不正确，请重新输入！");
            }
            throw new RuntimeException("输入的操作符不符合规范！");
        }

    public void showStudents(List<Student> students) {
        for(Student s : students){
            System.out.println(s);
        }
    }
    //这里可以
    public String adduced() {
        System.out.println("请输入需要插入的学生姓名:");
        String name = sc.next();
        System.out.println("请输入需要插入的学生性别:");
        String sex = sc.next();
        System.out.println("请输入需要插入的学生班级:");
        String classname = sc.next();
        String sql = "INSERT into t_student(t_student.`name`,t_student.sex,t_student.classname) VALUES('"+name+"','"+sex+"','"+classname+"')";
        System.out.println(sql);
        return sql;
    }

    public void showSucess() {
        System.out.println("操作成功！");
    }

    public void showfailue() {
        System.out.println("操作失败！");
    }

    public String delStudent() {
        System.out.println("请输入删除的学生id:");
        String id = sc.next();
        String sql = "DELETE FROM t_student WHERE t_student.id = '"+id+"'";
        System.out.println(sql);
        return sql;
    }

    public String edStudent() {
        System.out.println("请输入编辑的学生id:");
        String id = sc.next();
        String sql = "UPDATE t_student set t_student.sex = '女' WHERE t_student.id = '"+id+"'";
        System.out.println(sql);
        return sql;
    }

    public void showBreak() {
        System.out.println("感谢使用！");
    }

    public void showError() {
        System.out.println("输入操作符不符合规范，请重新输入！");
    }
}

controller包

package com.situ.controller;

import com.situ.dao.StudentDAO;
import com.situ.model.Student;
import com.situ.view.StudentView;

import java.util.List;

/**
 * @author : 一只小海猪
 * @date : 20:48 2021/11/11
 */
public class StudentController {
    private StudentDAO dao = new StudentDAO();
    private StudentView view = new StudentView();

//    public void setDao(StudentDAO dao) {
//        this.dao = dao;
//    }
//
//    public void setView(StudentView view) {
//        this.view = view;
//    }

    public void start(){
        while(true) {
            String choice = view.showMenu();
            if ("1".equals(choice)) {
                addStudent();
            } else if ("2".equals(choice)) {
                editStudent();
            } else if ("3".equals(choice)) {
                deleteStudent();
            } else if ("4".equals(choice)) {
                showAllStudent();
            } else if ("5".equals(choice)) {
                view.showBreak();
                break;
            }else{
                view.showError();
            }
        }
    }

    private void deleteStudent() {
        int i = dao.delete(view.delStudent());
        if(i>0){
            view.showSucess();
        }else{
            view.showfailue();
        }
    }

    private void editStudent() {
        int i = dao.edit(view.edStudent());
        if(i>0){
            view.showSucess();
        }else{
            view.showfailue();
        }
    }

    private void addStudent() {
       int i =dao.add( view.adduced());
       if(i>0){
           view.showSucess();
       }else{
           view.showfailue();
       }
    }

    private void showAllStudent() {
        List<Student> students = dao.findAll();
        view.showStudents(students);
    }

}

dao包

package com.situ.dao;

import com.situ.JDBC.BeanListHandler;
import com.situ.JDBC.JdbcUtils;
import com.situ.model.Student;

import java.sql.Connection;
import java.util.List;

import static com.situ.model.GlobalConstants.*;

/**
 * @author : 一只小海猪
 * @date : 20:48 2021/11/11
 */
public class StudentDAO {

    public List<Student> findAll() {
        return JdbcUtils.query(JdbcUtils.getConnection(url,user,password),new BeanListHandler<Student>(Student.class),"select id ,`name`,sex,classname from t_student",new Object[]{} );
    }
    //简单实现MVC，等到熟练后，只需要用户输入参数即可，程序可以自动组装SQL语句
    //INSERT into t_student(t_student.id,t_student.`name`,t_student.sex,t_student.classname) VALUES('4','龙哥','男','2101java')
    public int add(String sql){
        return JdbcUtils.insertToSQL(JdbcUtils.getConnection(url,user,password),sql,new Object[]{});
    }

    //DELETE FROM t_student WHERE t_student.id = '4'
    public int delete(String sql) {
        return JdbcUtils.deleteFromSQL(JdbcUtils.getConnection(url,user,password),sql,new Object[]{});
    }

    //UPDATE t_student set t_student.sex = '女' WHERE t_student.id = '4'
    public int edit(String sql) {
        return JdbcUtils.deleteFromSQL(JdbcUtils.getConnection(url,user,password),sql,new Object[]{});
    }
}

JDBCUtilS包

连接的获取，关闭，及数据库的操作

package com.situ.JDBC;

import java.sql.*;

/**
 * @author : 一只小海猪
 * @date : 14:25 2021/11/10
 */
public class JdbcUtils {
    public static final String driver = "com.mysql.cj.jdbc.Driver";

    //获取连接数据库的对象
    public static final Connection getConnection( String driver,String url, String user,String password) {

        try {
            Class.forName(driver);
            Connection conn = DriverManager.getConnection(url,user,password);
            return conn;
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        throw new RuntimeException("数据库连接失败！");
    }

    //重载获取连接数据库的对象
    public static final Connection getConnection(String url, String user,String password){
        return getConnection(driver,url,user,password);
    }

    //通过用户输入的查询sql语句，执行这个语句，返回查询结果集
    public static final ResultSet selectFromSQL(Connection conn , String sql,Object[] args){
        try {
            PreparedStatement ps = conn.prepareStatement(sql);
            if(args != null){
                //给PreperedStatement实例设置参数
                for(int i = 0 ; i<args.length ;i++){
                    ps.setObject(i+1,args[i]);
                }
            }
            return ps.executeQuery();
        } catch (SQLException e) {
            e.printStackTrace();
        }

        throw new RuntimeException("数据库查询失败！");
    }


    //更新函数,支持增删改
    public  static final int updateToSQL(Connection conn,String sql ,Object[] args){
        try {
            PreparedStatement ps = conn.prepareStatement(sql);
            if(args != null){
                //sql语句内的？号实例设置参数
                for(int i = 0 ; i < args.length ; i++){
                    ps.setObject(i+1,args[i]);
                }
            }
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        throw new RuntimeException("操作数据失败！");

    }


    //通过用户输入的插入sql语句，执行这个语句，返回插入行数
    public static final int insertToSQL(Connection conn, String sql,Object[] args){
        //调用更新数据库函数
       return updateToSQL(conn,sql,args);
    }


    //通过用户输入的sql语句，执行这个修改sql语句，返回修改行数
    public static final int editToSQL(Connection conn, String sql,Object[] args){
        //调用更新数据库函数
        return updateToSQL(conn,sql,args);
    }


    //通过用户输入的删除sql语句，执行sql语句，返回删除结果
    public static final int deleteFromSQL(Connection conn,String sql,Object[] args){
        //调用更新数据库函数
        return updateToSQL(conn,sql,args);
    }

    //获取用户输入的对象类型，将数据库中获取的数据封装成对象加入对象集合中，返回这个集合
    public static <T> T query(Connection conn ,ResultSetHandler<T> handler, String sql , Object[] args){
        ResultSet rs  =  selectFromSQL(conn,sql,args);
//        if(rs!=null) {
//            try {
//                while (rs.next()) {
//                    Student s = new Student();
//                    s.setId(rs.getInt("id"));
//                    s.setName(rs.getString("name"));
//                    s.setSex(rs.getString("sex"));
//                    s.setBirthday(rs.getDate("birthday"));
//                    s.setClassname(rs.getString("classname"));
//                    System.out.println("成功读取 "+s);
//                }
//            } catch (SQLException e) {
//                // TODO Auto-generated catch block
//                e.printStackTrace();
//            }
//        }
        return handler.handle(rs);
    }

    public static final void closeConnection(Connection conn){
        try {
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

获取用户输入对象的类型，给T指定类型的接口

package com.situ.JDBC;

import java.sql.ResultSet;

/**
 * @author : 一只小海猪
 * @date : 17:28 2021/11/10
 */
public interface ResultSetHandler<T> {
    T handle(ResultSet rs);
}

通过反射，封装对象，并加入集合，返回集合接口

package com.situ.JDBC;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author : 一只小海猪
 * @date : 18:43 2021/11/10
 */
public class BeanListHandler<T> implements ResultSetHandler<List<T>> {
    private Class<T> clazz;
    //获取用户输入的对象映射
    public BeanListHandler(Class<T> clazz) {
        this.clazz = clazz;
    }

    @Override
    public List<T> handle(ResultSet rs) {
        int flag = 0 ;
        List<T> list = new ArrayList<>();//存储对象
        List<String> columnNames = new ArrayList<>();//存储数据库列名
        Map<String , Method> map = new HashMap<>();//根据列名存储相应的set方法
        Method[] methods = clazz.getDeclaredMethods();//反射获取set方法集合

        try {
            ResultSetMetaData rsmd = rs.getMetaData();
            int count = rsmd.getColumnCount();//列名数量
            //获取元数组，并拼接方法，以键值对的方式存入map
            for(int i =0 ;i<count;i++){
                String columnName = rsmd.getColumnLabel(i+1);//获取列名
                columnNames.add(columnName);//将列名存入列名集合
                //拼接方法名
                String methondName = "set" + columnName.substring(0,1).toUpperCase()+columnName.substring(1);

                //将方法和列名以键值对的方式存入map
                for(Method m:methods){
                    if(m.getName().equals(methondName)){
                        map.put(columnName,m);
                        break;
                    }
                }

            }
            Constructor<T> con = clazz.getDeclaredConstructor();//反射获取对象的构造方法

            if(rs != null){
                while(rs.next()){
                  T t = con.newInstance();  //反射创建一个新对象

                    for(int i = 0 ; i<count ; i++){
                        String clonmnName = columnNames.get(i);//获取列名
                        Object obj = rs.getObject(clonmnName);//通过列名获取对应的属性值
                        Method m = map.get(clonmnName);//通过列名获取对应的set方法名
                        m.invoke(t,obj);//用对应的方法给对象的对应属性赋值
                    }

                    list.add(t);
                    flag++;
                }
            }

        } catch (SQLException | NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        System.out.println("一共获取了"+flag+"个对象！");
        return list;
    }
}

main包

测试类，即启动系统

package com.situ.main;

import com.situ.controller.StudentController;

/**
 * @author : 一只小海猪
 * @date : 20:48 2021/11/11
 *
 * 目前只是简单通过用户输入SQL语句来执行操作，
 * 等到熟练使用MVC后就可以只需要用户输入参数，程序可以自动组装SQL语句，并执行
 */
public class Test2 {
    public static void main(String[] args) {
        StudentController controller = new StudentController();
        controller.start();
    }


}

运行效果

这里只是简单实现，即只是使用用户输入SQL语句来实现操作，但是重在熟悉MVC，等到熟练后，可以通过用户输入的参数来组装sql语句！