基于CMS项目的JDBC的实战

使用的Javase技术，进行控制台输出的客户管理系统（CMS），主要功能包含登录，注册、客户信息的展示，客户信息的更新，客户信息添加删除客户、退出系统。

设计创建数据库

create table t_customer(
id INT PRIMARY KEY AUTO_increment,
cname VARCHAR(20),
gender VARCHAR(4),
age INT,
phone VARCHAR(11),
address varchar(50)
)COMMENT '客户信息表';
TRUNCATE users;

搭建项目结构

在这里插入图片描述

工具类

jdbc.properties

driverClassName = com.mysql.cj.jdbc.Driver
url= jdbc:mysql://localhost:3306/studydb
username=root
password=

initialSize=5

minIdle=3

maxActive =10

public class JDBCUtil {
private static String driverClassName;
private static String url;
private static String username;
private static String password;
static {
InputStream is=
JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
Properties prop = new Properties();
try {
prop.load(is);
driverClassName = prop.getProperty("driverClassName");
url = prop.getProperty("url");
username = prop.getProperty("username");
password = prop.getProperty("password");
Class.forName(driverClassName);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
//1 获取连接
public static Connection getConnection(){
Connection conn = null;
try {
conn = DriverManager.getConnection(url,username,password);
} catch (SQLException e) {
throw new RuntimeException(e);
}
return conn;
}

/**

该代码是一个 JDBC 工具类，用于获取数据库连接和数据源。具体分析如下：
1. 读取配置文件
使用 JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties") 读取类路径下的 jdbc.properties 配置文件，获取数据库连接信息。
1. 加载数据库驱动
使用 Class.forName(driverClassName) 加载数据库驱动，这里的 driverClassName 是从配置文件中读取的。
1. 获取连接
使用 DriverManager.getConnection(url, username, password) 获取数据库连接，这里的 url、username 和 password 同样是从配置文件中读取的。
1. 获取数据源
使用 DruidDataSourceFactory.createDataSource(prop) 获取 Druid 数据源，这里的 prop 是从配置文件中读取的。
1. 异常处理
在代码中使用了运行时异常 RuntimeException，可以让调用者在出现异常时更方便地处理异常。同时，在代码中也没有进行资源的关闭，调用者需要注意及时关闭连接或数据源，避免资源泄漏。
*/

创建实体

public class User {
private int id;
private String username;
private String password;
public User() {
}
public User(String username, String password) {
this.username = username;
this.password = password;
}
public User(int id, String username, String password) {
this.id = id;
this.username = username;
this.password = password;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
/**
 * 这段代码是一个Java实体类，表示一个用户对象。
 * 其中包含了用户的id、用户名和密码属性，并提供了无参构造方法、含参构造方法和getter/setter方法。
 * 此外，还重写了toString()方法，方便输出用户信息。
 */

public class Customer {
private int id;
private String cname;
private String gender;
private int age;
private String phone;
private String address;
public Customer() {
}
public Customer(String cname, String gender, int age, String phone, String
address) {
this.cname = cname;
this.gender = gender;
this.age = age;
this.phone = phone;
this.address = address;
}
public Customer(int id, String cname, String gender, int age, String phone,
String address) {
this.id = id;
this.cname = cname;
this.gender = gender;
this.age = age;
this.phone = phone;
this.address = address;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getCname() {
return cname;
}
public void setCname(String cname) {
this.cname = cname;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Customer{" +
"id=" + id +
", cname='" + cname + '\'' +
", gender='" + gender + '\'' +
", age=" + age +
", phone='" + phone + '\'' +
", address='" + address + '\'' +
'}';
}
}
/**
 * 这段代码定义了一个名为Customer的实体类，包含了顾客的基本信息属性，
 * 如id、姓名、性别、年龄、电话和地址，并提供了构造方法和getter/setter方法。
 * 在toString()方法中，将对象的属性值以字符串的形式输出，以便于调试和查看。
 */

实现DAO层

因为在这里我们使用druid数据源所以在获取的时候我们就不需要在直接获取连接，而是通过druid给我们来创建处一个数据源
所以对我们的jdbcUtils进行升级改造

public class JDBCUtil {
//1 获取连接
public static DataSource getDatasource(){
InputStream is=
JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
Properties prop = new Properties();
DataSource dataSource = null;
try {
prop.load(is);
dataSource = DruidDataSourceFactory.createDataSource(prop);
} catch (Exception e) {
throw new RuntimeException(e);
}
return dataSource;
}
}

public class CustomerDao {
// 查询所有客户
public List<Customer> selectAll() throws SQLException {
QueryRunner runner = new QueryRunner(JDBCUtil.getDatasource());
String sql = "select * from t_customer";
List<Customer> list = runner.query(sql,new BeanListHandler<>
(Customer.class));
return list;
}
// 根据id查询某个客户
public Customer selectCustomerById(int id) throws SQLException {
QueryRunner runner = new QueryRunner(JDBCUtil.getDatasource());
String sql = "select * from t_customer where id=?";
Customer customer = runner.query(sql,new BeanHandler<>(Customer.class),id);
return customer;
}
//根据姓名查询某个客户
public Customer selectCustomerByName(String cname) throws SQLException {
QueryRunner runner = new QueryRunner(JDBCUtil.getDatasource());
String sql = "select * from t_customer where cname=?";
Customer customer = runner.query(sql,new BeanHandler<>
(Customer.class),cname);
return customer;
}
// 新增客户
public int insertCustomer(Customer customer) throws SQLException {
String sql = "insert into t_customer(cname,gender,age,phone,address)
values(?,?,?,?,?)";
QueryRunner qr = new QueryRunner(JDBCUtil.getDatasource());
int rows =
qr.update(sql,customer.getCname(),customer.getGender(),customer.getAge(),customer.ge
tPhone(),customer.getAddress());
return rows;
}
// 修改客户信息
public int updateCustomer(Customer customer) throws SQLException {
String sql = "update t_customer set cname =?
,gender=?,age=?,phone=?,address=? where id=?";
QueryRunner qr = new QueryRunner(JDBCUtil.getDatasource());
int rows =
qr.update(sql,customer.getCname(),customer.getGender(),customer.getAge(),customer.ge
tPhone(),customer.getAddress(),customer.getId());
return rows;
}
//删除客户信息
public int deleteCustomer(int id) throws SQLException {
String sql = "delete from t_customer where id=?";
QueryRunner qr = new QueryRunner(JDBCUtil.getDatasource());
int rows = qr.update(sql,id);
测试
1.8.Service层
return rows;
}
}

/**

这是一个客户管理系统的DAO层代码，使用了Apache Commons DbUtils工具类库进行数据库操作。具体分析如下：
1. 导入依赖包：
import cn.sxjzlgxy.cms.entity.Customer;
import cn.sxjzlgxy.cms.utils.JDBCUtil;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
1. selectAll()方法：查询所有客户信息，返回一个Customer对象列表。
1. selectCustomerById()方法：根据id查询某个客户信息，返回一个Customer对象。
1. selectCustomerByName()方法：根据姓名查询某个客户信息，返回一个Customer对象。
1. insertCustomer()方法：新增客户信息，返回受影响的行数。
1. updateCustomer()方法：修改客户信息，返回受影响的行数。
1. deleteCustomer()方法：删除客户信息，返回受影响的行数。
总体来说，这些方法都是对数据库的基本操作，使用了DbUtils提供的QueryRunner类和ResultSetHandler接口来执行SQL语句和处理查询结果，从而简化了代码。
*/

public class UsersDao {
// 根据用户的用户名和密码查询用户
public User selectUserByUsernameAndPassword(String username,String password)
throws SQLException {
// 使用dbutils完成用户数据的查询
String sql = "select * from users where username=? and password= ?";
QueryRunner qr = new QueryRunner(JDBCUtil.getDatasource());
//对密码进行加密之后 进行查询
password = Md5Crypt.apr1Crypt(password,"sxjzit");
System.out.println(password);
User user = qr.query( sql,new BeanHandler<>(User.class),username ,password);
return user;
}
// 新增用户
public int insertUser(User user) throws SQLException {
String encodePas = Md5Crypt.apr1Crypt(user.getPassword(),"sxjzit");
user.setPassword(encodePas);
String sql = "insert into users(username,password) values(?,?)";
QueryRunner qr = new QueryRunner(JDBCUtil.getDatasource());
int rows = qr.update(sql,user.getUsername(),user.getPassword());
return rows;
}
}

/**

该代码是一个用户数据访问对象（DAO）。该类提供了两个方法，分别用于查询用户和新增用户。
其中，selectUserByUsernameAndPassword() 方法用于根据用户名和密码查询用户。该方法使用了 Apache Commons DbUtils 库中的 QueryRunner 类来执行 SQL 查询。在执行查询之前，该方法对密码进行了加密，并使用 BeanHandler 将查询结果转换为 User 对象。
insertUser() 方法用于新增用户。该方法同样使用 QueryRunner 执行 SQL 插入语句，并在插入之前对密码进行了加密。
最后，该类还包含了两个测试方法，用于测试查询用户和新增用户的功能。
*/
测试

@Test
public void selectUserByUsernameAndPasswordTest() throws SQLException {
UsersDao dao = new UsersDao();
User user = dao.selectUserByUsernameAndPassword("admin","123456");
System.out.println(user);
}
@Test
public void insertUserTest() throws SQLException {
UsersDao dao = new UsersDao();
User user = new User("admin","123456");
dao.insertUser(user);
}
}

Service层

public interface IUserService {
Boolean login(String username,String password) throws SQLException;
Boolean regist(User user) throws SQLException;
}

/**该代码定义了一个接口IUserService，

该接口提供了两个方法：login和regist，分别用于用户登录和用户注册。
其中，login方法接收两个参数username和password，
返回一个布尔类型的值，表示登录是否成功；
regist方法接收一个User类型的参数user，
返回一个布尔类型的值，表示注册是否成功。
该接口的实现类需要对这两个方法进行具体实现。*/

public class UserServiceImpl implements IUserService {
private UsersDao dao = new UsersDao();
@Override
public Boolean login(String username, String password) throws SQLException {
User user = dao.selectUserByUsernameAndPassword(username,password);
if (user !=null){
return true;
}
return false ;
}
@Override
public Boolean regist(User user) throws SQLException {
int rows= dao.insertUser(user);
if(rows > 0){
return true;
}
return false;
}
}

/**

该代码实现了一个用户服务的接口IUserService，其中包含了用户登录和注册的方法。具体实现是通过调用一个名为UsersDao的数据访问对象来进行数据库操作。
在登录方法中，通过传入的用户名和密码查询数据库中是否存在该用户，如果存在则返回true，否则返回false。
在注册方法中，将用户对象插入到数据库中，如果插入成功则返回true，否则返回false。
*/

public interface ICustomerService {
List<Customer> queryAll();
Customer queryOneById(int id);
Customer queryOneByName(String name);
int addCustomer(Customer customer);
int modifyCustomer(Customer customer);
int removerCustomer(int id);
}

/**这是一个客户信息管理系统的服务层接口，定义了客户信息的增删改查方法。具体分析如下：

方法列表：

queryAll()：查询全部客户信息
queryOneById(int id)：根据客户ID查询单个客户信息
queryOneByName(String name)：根据客户姓名查询单个客户信息
addCustomer(Customer customer)：添加客户信息
modifyCustomer(Customer customer)：修改客户信息
removerCustomer(int id)：删除客户信息

方法参数：

queryAll()：无参数
queryOneById(int id)：客户ID
queryOneByName(String name)：客户姓名
addCustomer(Customer customer)：客户信息对象
modifyCustomer(Customer customer)：客户信息对象
removerCustomer(int id)：客户ID

方法返回值：

queryAll()：返回客户信息列表
queryOneById(int id)：返回单个客户信息对象
queryOneByName(String name)：返回单个客户信息对象
addCustomer(Customer customer)：返回添加结果，成功返回1，失败返回0
modifyCustomer(Customer customer)：返回修改结果，成功返回1，失败返回0
removerCustomer(int id)：返回删除结果，成功返回1，失败返回0

抛出异常：

所有方法都可能会抛出SQLException异常，表示操作数据库时出现错误。

总之，该接口定义了客户信息管理系统的基本操作方法，实现类需要根据具体的业务逻辑来实现这些方法。*/

public class CustomerServiceImpl implements ICustomerService {
private CustomerDao dao = new CustomerDao();
@Override
public List<Customer> queryAll() throws SQLException {
return dao.selectAll();
}
@Override
public Customer queryOneById(int id) throws SQLException {
return dao.selectCustomerById(id);
}
@Override
public Customer queryOneByName(String name) throws SQLException {
return dao.selectCustomerByName(name);
}
@Override
public int addCustomer(Customer customer) throws SQLException {
return dao.insertCustomer(customer);
}
@Override
public int modifyCustomer(Customer customer) throws SQLException {
return dao.updateCustomer(customer);
}
@Override
public int removerCustomer(int id) throws SQLException {
return dao.deleteCustomer(id);
}
}

/**

这段代码是一个客户信息的服务层实现类，实现了ICustomerService接口中定义的方法。其中，私有成员变量dao是一个CustomerDao对象，用于调用该类中定义的数据库操作方法。实现的方法包括：
- queryAll()：查询所有客户信息；
- queryOneById(int id)：根据id查询单个客户信息；
- queryOneByName(String name)：根据name查询单个客户信息；
- addCustomer(Customer customer)：添加一个客户信息；
- modifyCustomer(Customer customer)：修改一个客户信息；
- removerCustomer(int id)：根据id删除一个客户信息。
这些方法都会抛出SQLException异常，因为涉及到数据库操作，可能会出现异常。
*/

Controller层

public class UserController {
private IUserService userService = new UserServiceImpl();
public String login(String username,String password){
try {
Boolean flag = userService.login(username, password);
if (flag){
return "success";
}
} catch (SQLException e) {
throw new RuntimeException(e);
}
return "fail";
}
public String register(String username,String password){
User user = new User(username,password);
try {
Boolean flag = userService.regist(user);
if(flag)
return "success";
} catch (SQLException e) {
throw new RuntimeException(e);
}
return "fail";
}
}

/**

这段代码实现了一个用户控制器，包括登录和注册两个方法。
其中，登录方法调用了IUserService接口中的login方法，传入用户名和密码，如果返回true，则返回字符串"success"，否则返回"fail"。
注册方法创建了一个User对象，调用了IUserService接口中的regist方法，传入创建的User对象，如果返回true，则返回字符串"success"，否则返回"fail"。
如果在调用过程中出现SQLException异常，则抛出RuntimeException异常。
*/

public class CustomerController {
private ICustomerService service = new CustomerServiceImpl();
public void customerListShow() throws SQLException {
List<Customer> customerList = service.queryAll();
System.out.println("姓名\t\t年龄\t\t性别\t\t电话\t\t\t\t地址");
for (Customer c : customerList){
System.out.println(c.getCname()
+"\t\t"+c.getAge()+"\t\t"+c.getGender()+"\t\t"+c.getPhone()+"\t\t"+c.getAddress());
}
}
public Customer customer(int id) throws SQLException {
return service.queryOneById(id);
}
public Customer customer(String name) throws SQLException {
return service.queryOneByName(name);
}
public void updateCustomer(Customer customer) throws SQLException {
service.modifyCustomer(customer);
}
}

/**

这段代码实现了一个客户管理系统的控制器，
其中包括了查询所有客户、根据id或姓名查询客户、修改客户信息等功能。
具体地，该控制器调用了一个名为CustomerServiceImpl的客户服务接口的实现类，通过该实现类实现了相应的功能。
其中，查询所有客户的方法通过调用查询所有客户的方法并遍历打印出来，
根据id或姓名查询客户的方法通过调用查询单个客户的方法实现，
修改客户信息的方法通过调用修改客户信息的方法实现。
*/

UI层

public class UserUi {
private UserController controller = new UserController();
public void UserMenu(){
System.out.println("----------欢迎进入CMS系统）------------------");
Scanner sc = new Scanner(System.in);
while(true){
System.out.println("1、登录");
System.out.println("2、注册");
System.out.println("请选择您要进行的操作:");
int option = sc.nextInt();
switch (option){
case 1:
System.out.println("请输入您的账号：");
String username = sc.next();
System.out.println("请输入您的密码：");
String password = sc.next();
String msg = controller.login(username,password);
System.out.println(msg);
if ("登录成功".equals(msg)){
//TDDO 进入到CustomerUI
}
break;
case 2:
System.out.println("请输入您要注册的账号：");
String uname = sc.next();
System.out.println("请输入您要使用的密码：");
String pwd = sc.next();
String res = controller.register(uname,pwd);
System.out.println(res);
break;
}
}
}
}

/**

该代码为用户界面的实现类，提供了用户登录和注册的菜单选项，
并通过调用UserController中的方法来实现用户登录和注册的功能。
在用户登录成功后，进入到CustomerUi界面。
*/

public class CustomerUi {
private CustomerController controller = new CustomerController();
public void CustomerMenu(Scanner sc, String username) throws SQLException {
while(true){
System.out.println("欢迎您："+username);
System.out.println("1、查询所有客户信息");
System.out.println("2、根据姓名查询客户信息");
System.out.println("3、修改客户信息");
System.out.println("4、删除客户信息");
System.out.println("请输入你要进行的操作（1、2、3、4）：");
int option = sc.nextInt();
switch (option){
case 1:
controller.customerListShow();
break;
case 2:
System.out.println("请输入你要查询的客户的姓名：");
String cname = sc.next();
Customer c = controller.customer(cname);
System.out.println(c);
break;
case 3:
controller.customerListShow();
System.out.println("请输入你要修改的客户的id：");
int id = sc.nextInt();
Customer c1 = controller.customer(id);
System.out.println("请输入该客户的新的名称：");
String name = sc.next();
c1.setCname(name);
controller.updateCustomer(c1);
controller.customerListShow();
break;
default:
System.out.println("您的选择有误，请重新选择！");
break;
}
}
}
}

/**

该代码是一个客户管理系统的用户界面类，主要实现了客户管理系统的菜单功能，包括查询所有客户信息、根据姓名查询客户信息、修改客户信息和删除客户信息等功能。
在菜单功能实现中，使用了Scanner类获取用户输入的选项，并根据用户选择的不同选项调用不同的Controller类中的方法实现不同的功能。其中，客户信息的查询和修改操作需要先展示客户列表，然后根据用户输入的客户id或客户姓名获取对应的客户信息进行操作。
该代码还提供了一个exit()方法，用于退出程序。
*/

启动类

public class Main {
public static void main(String[] args) throws SQLException {
UserUi userUi = new UserUi();
Scanner sc = new Scanner(System.in);
userUi.UserMenu(sc);
}
}