单例Bean工厂的实现

最新推荐文章于 2024-06-25 16:26:32 发布
最新推荐文章于 2024-06-25 16:26:32 发布
阅读量224 收藏
点赞数
文章标签： 数据库 java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43625140/article/details/108538168
版权

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.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * @className BeanFactoryUtil
 * @description Bean工厂工具类
 * @author 周威
 * @date 2020-09-08 11:20
 **/
public class BeanFactoryUtil
{
    // 定义Bean配置文件名
    private static final String CONFIG_FILE_NAME = "beanfactory_config.properties";
    // 定义Bean配置集合
    private static Properties properties;
    // 定义Bean存储容器
    private static Map<String, Object> container;

    static
    {
        InputStream is = null;
        try
        {
            // 创建集合容器
            properties = new Properties();
            // 获取配置文件字节输入流
            is = BeanFactoryUtil.class.getClassLoader().getResourceAsStream(CONFIG_FILE_NAME);
            // 加载配置文件内容到集合
            properties.load(is);
            // 创建Bean容器
            container = new HashMap<>();
        }
        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)
    {
        // 从Bean容器获取Bean
        Object object = container.get(beanName);
        if (object == null)
        {
            try
            {
                // 获取字节码对象
                Class classObject = Class.forName(properties.getProperty(beanName));
                // 创建Bean对象
                object = classObject.newInstance();
                // 将Bean对象存入Bean容器
                container.put(beanName, object);
            }
            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-08 11:11
 **/
public class DBUtil
{
    // 数据库连接四个条件
    private static final String JDBC_MYSQL_DRIVER = "com.jdbc.mysql.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();
        }
    }

    /**
     * 获取数据库连接
     * @return 数据库连接对象
     */
    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;
    }

    /**
     * 关闭数据库连接资源
     * @param connection
     * @param preparedStatement
     * @param resultSet
     */
    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-08 9:01
 **/
@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-08 11:29
 **/
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.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-08 11:31
 **/
public class UserDaoImpl implements UserDao
{
    @Override
    public List<UserDO> listUserInformations()
    {
        List<UserDO> result = new ArrayList<>();

        // 定义数据库连接资源
        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())
            {
                // 解析结果集
                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");

                // 组装用户数据
                UserDO user = new UserDO();
                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-08 11:48
 **/
public interface UserService
{
    /**
     * 查询用户信息业务，查询所有用户信息
     * @return 用户信息列表
     */
    List<UserDO> lisetUserInformations();
}

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-08 11:50
 **/
public class UserServiceImpl implements UserService
{
    // 注入用户持久层Bean
    private UserDao userDao = (UserDao) BeanFactoryUtil.createBean("userDao");

    @Override
    public List<UserDO> lisetUserInformations()
    {
        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-08 11:52
 **/
public class UserController
{
    public static void main(String[] args)
    {
        // 注入用户业务层Bean
        UserService userService = (UserService) BeanFactoryUtil.createBean("userService");
        // 进行查询业务信息处理
        List<UserDO> users = userService.lisetUserInformations();
        // 打印用户信息
        for (UserDO user : users)
        {
            System.out.println("user = " + user);
        }
    }
}

14. 运行测试

在这里插入图片描述

15. 单例工厂测试类

package zw.spring.controller;

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

/**
 * @className TestController
 * @description 单例Bean工厂测试类
 * @author 周威
 * @date 2020-09-08 12:20
 **/
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. 运行测试

在这里插入图片描述

-无事小神仙-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单例模式（Singleton）、工厂模式（Factory） 、代理（Proxy）模式
Amo_a_te的博客
12-07 1668
。。。。。。。。。
使用工厂模式实现单例
Block_chain的博客
09-20 1061
最近一直在看设计模式和基本原则，下面分享一个使用工厂模式实现单例。因为工厂模式我们在日常的开发中比较常用。所以最近get了一下。 1.首先写一个自己需要的单例模式。根据自己的业务而定。 package com.singleton.cn; public class Singleton { private Singleton() { } public void doSomething(...
模拟实现spring的bean工厂
beckham
01-27 805
spring的IOC容器时运用工厂模式实现的，我也简单的模拟一下bean工厂。 场景：定义一个接口 Person，里面有个方法 speek()，说话，Boy可以实现speek，Girl当然也可以实现 当我们需要获取具体的boy或girl对象时，我们的设计思路是直接从我们创建的工厂里面获取，而不需要自己new出来。 package com.beckham.spring;/
Spring底层原理之FactoryBean Bean工厂 单例对象 多例对象
最新发布
雨花石的博客
06-25 1285
在 Spring Framework 中，FactoryBean 是一个用于创建其他 Bean 实例的特殊工厂 Bean。它允许开发者自定义 Bean 的创建逻辑，从而更加灵活地管理和配置 Bean 的实例化过程。 FactoryBean 接口 FactoryBean 接口是 Spring 框架中的一个重要接口，它定义了两个方法： getObject()：这个方法负责返回由工厂创建的 Bean 的实例，可以是任意的对象，不限于特定的类或接口。 getObjectType()：这个方法返回由工厂创建的
突发奇想的 通用单例bean工厂
新菜嚻最火的博客
11-11 128
某天胡思乱想的脑袋突然出现了个想法，之前接触过一个通用的builder模式工具类，就想单例bean工厂模式下是不是也可行，就抱着想法来了。 首先那要确保单例bean的获取，bean对象类的getInstance方法和私有化的构造函数必不可少; 然后又因为通用的builder模式是要用到 new 的，又想到java的反射，呲呲~这不就有了吗！ 通过反射获取bean getInstance（） 函数， 然后获取默认值这不就有了吗，来做出来实验下： /** * @author ljy on 2020/1
实现Bean工厂
Frank的博客
05-25 486
1 Bean工厂的作用 一开始，我写好了类1.1（定义接口+实现接口），我在类2中需要使用类1.1的功能，那么最简单的方法就是在类2中创建类1的对象，然后调用类1的方法（直接使用类1的静态方法另当别论） 后来，类1.1的功能需要增强才能满足新的需求了，要么直接修改类1.1，如果不想动类1.1，那就新建一个接口的实现类1.2 于是在类2中，又重新的创建类1.2的对象，使用类1.2新增的方法 上面的做法，虽然也很方便，但是问题在于“需要修改源代码”，至少需要在类2中重新创建新的需要使用的对象 如果要想不修改源
spring beanfactory --实现自己简单的 bean工厂类
aoliao5046的博客
04-05 200
当从BeanFactory中通过getBean()方法获取一个bean的时候，BeanFactory会经过如下的步骤来构建Bean的实例，这正是实例化Bean的过程： 从名字上看就是Spring的一个Bean工厂。如果单从工厂模式的角度思考，它就是用来“生产Bean”，然后提供给客户端。 1、调用Bean的默认构造方法，或者在指定的构造方法，生成bean实例（暂称为in...
工厂创建Bean对象（单例、多例）
qq_34721292的博客
05-07 1573
目录结构： package com.itheima.factory; import java.io.InputStream; import java.util.Enumeration; import java.util.HashMap; import java.util.Map; import java.util.Properties; /** * 一个创建Bean对象的工厂 * * ...
单例和factory
大大
07-29 688
public class Singleton {      private static Singleton instance;      private Singleton (){}        public static Singleton getInstance() {      if (instance == null) {          instance = new Sin
如何实现单例工厂类的几种解决方案
例子不吃栗子
05-27 475
现有文件： 用于调用的服务类 方法入口： public static <T> T getService(Class<? extends T> interfaceName) { //获取实例 } 方法一 将服务类继承于LocalService接口。 写一个工具类获取LocalService接口下所有实现类的类对象， 工厂类ServiceFactoryEx 里面利用工具类ConfigUtil 获取所有的类对象， 利用反射获取对应的实例 具体代码 继承 public c.
单例java类获取spring的bean方法
shang3583091的博客
03-21 844
单例类获取spring的bean /**  *   * @ClassName: AuthorityUtil   * @Description:  (获取数据权限类)   * @author zuoqiang  * @date 2017年2月6日 上午10:18:51   *  */ @Component public class AuthorityUtil { prote
Java Factory概念学习第一课 （单例、多例）
weixin_41059155的博客
02-27 273
Java Factory概念学习第一课 （单例、多例）单例的概念多例的概念 单例的概念 对于一个Car类: public class Car{ public void run(){ System.out.println(&quot;汽车突突突地跑&quot;); } } 另一个类来获得Car，也就是实例化这个Car，： public class Test{ publ...
单例模式的SessionFactory
wangmingguan的博客
06-18 165
需要在 hibernate.cfg.xml 中添加的配置[java] view plain copy print?&lt;property name="hibernate.current_session_context_class"&gt;thread&lt;/property&gt;  &lt;property name="hibernate.current_session_context_cl...
构造器创建bean底层源码解析
felix_alone2012的博客
03-26 157
这一节我们将从spring底层源码的角度为大家剖析spring构造bean实例的细节。
（四）BeanFactory初始化Singleton的实现细节
流连是谁的博客
05-11 4646
1.介绍 查看ApplicationContext的启动以及初始化部分的代码时，发现最终实现对象创建以及所有非懒加载的单例对象整体初始化，都是通过DefaultListableBeanFacotry来实现的 其中对象创建是通过beanFactory.getBean(xxx)来实现，而整体初始化是通过beanFactory.preInstantiateSingletons();来实现， 下面针对这...
Spring中的BeanFactory实现
热门推荐
学无止境
05-19 1万+
实现Spring中的BeanFactory概览具体代码如下：1. 接口：2. 三个实现类 分别实现接口的save() 方法 如下3. beans.xml4. beanFactory类：5. 测试：总结： 在spring中通过管理ioc的思想，将实例的创建于管理交由spring容器来管理。这里来简单的实现一下这个Spring的Bean工厂。 主要是 工厂+反射+配置文件 配合实现 概览 创建项目...
Spring如何解析循环依赖
zun95999的博客
10-31 197
什么是循环引用？ 比如对象A有属性B,对象B有属性A,这就是循环引用。 整个Spring Bean的创建分为：解析、注册、创建。循环引用则发生在bean的创建过程中。 废话不多上，直接上代码，以下是bean创建的核心代码： protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws Bean
等待单例工厂销毁完成后再创建新的单例bean 用java怎么写
07-13
在Java中，可以使用双重检查锁定（Double-Checked Locking）来实现等待单例工厂销毁完成后再创建新的单例bean。以下是一个示例代码： ```java public class SingletonFactory { private static volatile ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值