多例Bean工厂的实现

1. 准备数据库环境

# 新建用户表
CREATE TABLE IF NOT EXISTS `user` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `username` VARCHAR(32) NOT NULL COMMENT '用户名称',
  `birthday` DATETIME DEFAULT NULL COMMENT '生日',
  `sex` CHAR(1) DEFAULT NULL COMMENT '性别',
  `address` VARCHAR(256) DEFAULT NULL COMMENT '地址',
  `password` VARCHAR(100) DEFAULT NULL COMMENT '密码',
  CONSTRAINT pk_user PRIMARY KEY (`id`)
);

# 添加用户数据
INSERT  INTO 
  `user`(`id`,`username`,`birthday`,`sex`,`address`,`password`) 
VALUES 
(1,'周瑜','2020-02-27 17:47:08','男','吴国','123456'),
(2,'大乔','2020-02-27 15:09:37','女','吴国','123456'),
(3,'小乔','2020-02-27 11:34:34','女','吴国','123456'),
(4,'陆逊','2020-02-27 12:04:06','男','吴国','123456'),
(5,'孙策','2020-02-27 17:37:26','男','东吴','123456'),
(6,'孙权','2020-02-27 11:44:00','男','吴国','123456');

2. 创建maven工程

3. 项目依赖

<dependencies>
    <!-- mysql -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.49</version>
    </dependency>
    <!-- lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>
</dependencies>

4. 项目工程结构

5. Bean工厂配置文件

# Bean配置文件

# 用户持久层Bean
userDao=zw.spring.dao.impl.UserDaoImpl

# 用户业务层Bean
userService=zw.spring.service.impl.UserServiceImpl

6. Bean工厂工具类

package zw.spring.util;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * @className BeanFactory
 * @description Bean工厂工具类
 * @author 周威
 * @date 2020-09-07 18:44
 **/
public class BeanFactoryUtil
{
    private static final String CONFIG_NAME = "beanfactory_config.properties";
    private static Properties properties;

    static
    {
        InputStream is = null;
        try
        {
            // 创建集合对象
            properties = new Properties();
            // 获取配置文件字节输入流
            is = BeanFactoryUtil.class.getClassLoader().getResourceAsStream(CONFIG_NAME);
            // 加载配置文件内容到集合
            properties.load(is);
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            try
            {
                // 关闭流资源
                if (is != null)
                {
                    is.close();
                }
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }

    /**
     * 创建Bean对象
     * @param beanName
     * @return Bean对象
     */
    public static Object createBean(String beanName)
    {
        Object object = null;
        try
        {
            Class classObject = Class.forName(properties.getProperty(beanName));
            object = classObject.newInstance();
        }
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IllegalAccessException e)
        {
            e.printStackTrace();
        }
        catch (InstantiationException e)
        {
            e.printStackTrace();
        }
        return object;
    }
}

7. 数据库工具类

package zw.spring.util;

import java.sql.*;

/**
 * @className DBUtil
 * @description 数据库工具类
 * @author 周威
 * @date 2020-09-07 18:16
 **/
public class DBUtil
{
    // 数据库连接参数
    private static final String JDBC_MYSQL_DRIVER = "com.mysql.jdbc.Driver";
    private static final String JDBC_MYSQL_URL = "jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=false";
    private static final String JDBC_MYSQL_USERNAME = "root";
    private static final String JDBC_MYSQL_PASSWORD = "root";

    // 加载数据库驱动
    static
    {
        try
        {
            Class.forName(JDBC_MYSQL_DRIVER);
        }
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
    }

    // 获取数据库连接
    public static Connection getConnection()
    {
        Connection connection = null;
        try
        {
            connection = DriverManager.getConnection(JDBC_MYSQL_URL, JDBC_MYSQL_USERNAME, JDBC_MYSQL_PASSWORD);
        }
        catch (SQLException throwables)
        {
            throwables.printStackTrace();
        }
        return connection;
    }

    // 关闭数据库资源
    public static void closeConnection(Connection connection, PreparedStatement preparedStatement, ResultSet resultSet)
    {
        try
        {
            if (resultSet != null)
            {
                resultSet.close();
            }
            if (preparedStatement != null)
            {
                preparedStatement.close();
            }
            if (connection != null)
            {
                connection.close();
            }
        }
        catch (SQLException throwables)
        {
            throwables.printStackTrace();
        }
    }
}

8. 用户实体类

package zw.spring.domain;

import lombok.Data;
import java.io.Serializable;
import java.util.Date;

/**
 * @className UserDO
 * @description 用户实体类
 * @author 周威
 * @date 2020-09-07 18:12
 **/
@Data
public class UserDO implements Serializable
{
    /* 用户编号 */
    private Integer id;

    /* 用户账号 */
    private String username;

    /* 用户密码 */
    private String password;

    /* 用户生日 */
    private Date birthday;

    /* 用户性别 */
    private String sex;

    /* 用户籍贯 */
    private String address;
}

9. 用户持久层接口

package zw.spring.dao;

import zw.spring.domain.UserDO;
import java.util.List;

/**
 * @className UserDao
 * @description 用户持久层接口
 * @author 周威
 * @date 2020-09-07 18:10
 **/
public interface UserDao
{
    /**
     * 查询用户信息，查询所有用户信息
     * @return 用户信息列表
     */
    List<UserDO> listUserInformations();
}

10. 用户持久层实现类

package zw.spring.dao.impl;

import zw.spring.dao.UserDao;
import zw.spring.domain.UserDO;
import zw.spring.util.BeanFactoryUtil;
import zw.spring.util.DBUtil;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @className UserDaoImpl
 * @description 用户持久层实现类
 * @author 周威
 * @date 2020-09-07 18:28
 **/
public class UserDaoImpl implements UserDao
{
    public List<UserDO> listUserInformations()
    {
        List<UserDO> result = new ArrayList<UserDO>();

        // 定义数据库访问资源
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try
        {
            // 准备SQL语句
            String sql = "select * from user";
            // 获取数据库连接
            connection = DBUtil.getConnection();
            // 获取数据库操作对象
            preparedStatement = connection.prepareStatement(sql);
            // 执行SQL语句，获得查询结果集
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next())
            {
                UserDO user = new UserDO();
                // 解析结果集
                Integer id = resultSet.getInt("id");
                String username = resultSet.getString("username");
                String password = resultSet.getString("password");
                Date birthday = resultSet.getDate("birthday");
                String sex = resultSet.getString("sex");
                String address = resultSet.getString("address");
                // 组装用户数据
                user.setId(id);
                user.setUsername(username);
                user.setPassword(password);
                user.setBirthday(birthday);
                user.setSex(sex);
                user.setAddress(address);
                // 将用户数据存入容器
                result.add(user);
            }
        }
        catch (SQLException throwables)
        {
            throwables.printStackTrace();
        }
        finally
        {
            // 关闭数据库资源
            DBUtil.closeConnection(connection, preparedStatement, resultSet);
        }
        return result;
    }
}

11. 用户业务层接口

package zw.spring.service;

import zw.spring.domain.UserDO;
import java.util.List;

/**
 * @className UserService
 * @description 用户业务层接口
 * @author 周威
 * @date 2020-09-07 18:58
 **/
public interface UserService
{
    /**
     * 查询用户信息业务，查询所有用户信息
     * @return 用户信息列表
     */
    List<UserDO> listUserInformations();
}

12. 用户业务层实现类

package zw.spring.service.impl;

import zw.spring.dao.UserDao;
import zw.spring.domain.UserDO;
import zw.spring.service.UserService;
import zw.spring.util.BeanFactoryUtil;
import java.util.List;

/**
 * @className UserServiceImpl
 * @description 用户业务层实现类
 * @author 周威
 * @date 2020-09-07 19:04
 **/
public class UserServiceImpl implements UserService
{
    // 注入用户持久层对象
    private UserDao userDao = (UserDao) BeanFactoryUtil.createBean("userDao");

    public List<UserDO> listUserInformations()
    {
        return userDao.listUserInformations();
    }
}

13. 用户表现层控制器

package zw.spring.controller;

import zw.spring.domain.UserDO;
import zw.spring.service.UserService;
import zw.spring.util.BeanFactoryUtil;
import java.util.List;

/**
 * @className UserController
 * @description 用户表现层控制器
 * @author 周威
 * @date 2020-09-07 19:07
 **/
public class UserController
{
    public static void main(String[] args)
    {
        // 注入用户业务层对象
        UserService userService = (UserService) BeanFactoryUtil.createBean("userService");
        // 进行查询用户信息业务处理
        List<UserDO> users = userService.listUserInformations();
        // 打印用户信息
        for (UserDO user : users)
        {
            System.out.println("user = " + user);
        }
    }
}

14. 运行测试

15. 多例Bean工厂测试类

package zw.spring.controller;

import zw.spring.service.UserService;
import zw.spring.util.BeanFactoryUtil;

/**
 * @className TestController
 * @description 多例Bean工厂测试类
 * @author 周威
 * @date 2020-09-08 8:41
 **/
public class TestController
{
    public static void main(String[] args)
    {
        for (int i = 0; i < 10; i++)
        {
            UserService userService = (UserService) BeanFactoryUtil.createBean("userService");
            System.out.println("userService = " + userService);
        }
    }
}

16. 运行测试

• 每次获取Bean的地址都不一样，是多例生产的