权限管理（工厂模式）

在某OA系统中，系统根据对比用户在登录时输入的账号和密码以及在数据库中存储的账号和密码是否一致来进行身份验证，如果验证通过，则取出存储在数据库中的用户权限等级（以整数形式存储），根据不同的权限等级创建不同等级的用户对象，不同等级的用户对象拥有不同的操作权限。

效果演示：

需要导入的包：

数据表：

sql语句：

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` char(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `password` char(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `permission` int(255) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('100', '123456', 1);
INSERT INTO `user` VALUES ('102', '123456', 2);
INSERT INTO `user` VALUES ('103', '123456', 3);

SET FOREIGN_KEY_CHECKS = 1;

代码结构：

代码：
连接数据库：
mysql.properties文件：（以我自己的数据库user为例，用户名，密码都为root）

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/user?useSSL=true&characterEncoding=utf-8
username=root
password=root
maxActive=50
maxIdle=20
maxWait=60000

GetDBConnection类（用于连接数据库）：

package com.song.Util;

import org.apache.commons.dbcp.BasicDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

public class GetDBConnection {
    private static Connection conn;
    private static DataSource ds;

    static{
        try {
            //创建数据源的实例
            InputStream inStream = GetDBConnection.class.getResourceAsStream("mysql.properties");
            Properties properties = new Properties();
            properties.load(inStream);
            ds = BasicDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 获得数据库连接的方法
     * @return 数据库连接对象
     * @throws SQLException
     */
    public static synchronized Connection getConn() throws SQLException {
        if (conn == null || conn.isClosed()) {
            conn = ds.getConnection();
        }
        return conn;
    }
//    获得数据库操作语句
    public static PreparedStatement getPreparedStatement(Connection con, String sql, Object[] obj){
        PreparedStatement pre=null;
        if(con!=null){
            try {
                pre=con.prepareStatement(sql);
                for(int i=0;i<obj.length;i++){
                    pre.setObject(i+1,obj[i]);
//                    System.out.println(i+1);
//                    System.out.println(obj[i]);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
return pre;
    }
//    执行查询语句并获得结果
    public static ResultSet getResult(PreparedStatement pre){
        ResultSet rs=null;
        try {
            rs=pre.executeQuery();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return rs;
    }

//    执行非查询语句
    public static int execute(PreparedStatement pre){
        int rs=0;
        try {
            rs=pre.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return rs;
    }
    /**
     * 释放连接
     */
    public static void closeConn() {
        try {
            if (conn != null && !conn.isClosed()) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            conn = null;
        }
    }
}

USer类（抽象类）

package com.song.user;
public abstract class User {
public abstract void diff();
public void same()
    {
        System.out.println("共同操作权限");
    }
}

Administrator类（具体类）：

package com.song.user;
public abstract class User {
public abstract void diff();
public void same()
    {
        System.out.println("共同操作权限");
    }
}

President类（具体类）：

package com.song.user;
public class President extends User{
    @Override
    public void diff() {
        System.out.println("校长操作权限");
    }
}

Teacher类（具体类）：

package com.song.user;
public class Teacher extends User{
    @Override
    public void diff() {
        System.out.println("老师操作权限");
    }
}

UserFactory类：

package com.song.factory;
import com.song.user.Administrator;
import com.song.user.President;
import com.song.user.Teacher;
import com.song.user.User;
//简单工厂
public class UserFactory {
    public User CreateUser(String premission) {
        User user = null;
        if (premission.equals("1")) {
            user = new Administrator();
        } else if (premission.equals("2")) {
            user = new President();
        } else if (premission.equals("3")) {
            user = new Teacher();
        }
        return user;

    }
}

Accredit类（给用户赋予权限）：

package com.song.factory;
import com.song.user.User;
public class Accredit {
    UserFactory userFactory;
    //构造函数
    public Accredit(UserFactory userFactory) {
        setFactory(userFactory);
    }
    //给用户赋予权限
    public void setFactory(UserFactory userFactory) {
        User user= null;
        String premission;
        do {
            CheckUser cu=new CheckUser();
            //获得用户权限值
            premission =cu.getpremission();
            //调用用户工厂，根据用户权限值创建对应的用户
            user = userFactory.CreateUser(premission);
            if (user != null) {
                user.diff();
                user.same();
            }
        } while (true);
    }
}

CheckUse类（检查登录，获取权限值）：

package com.song.factory;
import com.song.Util.GetDBConnection;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class CheckUser {
    //检查用户名密码是否正确，如果正确则返回该用户的权限值，否则返回null
    public String check(String id,String password) throws SQLException {
        Connection con=null;
        PreparedStatement pre=null;
        ResultSet rs=null;
        String permission=null;
        String sqlstr="select * \n" +
                "from user\n"+
                "where id=? and  password=?";
        Object[] obj=new Object[2];
        obj[0]=id;
        obj[1]=password;
        con= GetDBConnection.getConn();
        pre= GetDBConnection.getPreparedStatement(con,sqlstr,obj);
        rs= GetDBConnection.getResult(pre);
        try {
            while (rs.next()){
                permission=rs.getString("permission");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            GetDBConnection.closeConn();
        }
        return permission;
    }
//根据输入的用户名密码，获得用户的等级
    public String getpremission() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(
                    System.in));
            String permission=null;
            while (permission==null){
                    System.out.println("----------------------------------------------------");
                    System.out.println("请输入账号:");
                    String id = strin.readLine();
                    System.out.println("请输入密码：");
                    String password = strin.readLine();
                    permission = check(id, password);//获得权限值
                    if(permission==null){
                        System.out.println("用户或密码错误，请重新输入！");
                    }
            }
            return permission;
        } catch (IOException | SQLException e) {
            e.printStackTrace();
            return "";
        }
    }

}

Login类（登录）：

package com.song.factory;
public class Login {
    public static void main(String[] args) {
        UserFactory userFactory=new UserFactory();
        Accredit accredit=new Accredit(userFactory);
    }
}

求关注，求关注，求关注！！！
可以直接问我要代码