DAY02_Spring—单例多例模式&懒加载&生命周期&DI&Spring容器管理三层代码结构&转义字符

最新推荐文章于 2024-04-13 16:55:35 发布
最新推荐文章于 2024-04-13 16:55:35 发布
阅读量412 收藏 10
点赞数 7
分类专栏： 5.框架+vue+京淘购物 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57075290/article/details/135607300
版权

目录

1 关于单例多例说明

1.1 关于Spring容器对象创建说明

  • Spring容器中默认的对象都是单例对象(通过构造方法实例化对象)
  • 有时需要通过多例对象为用户提供服务(数据源链接)

1.2 多例对象配置

  • 创建com.jt.pojo包
public class User {
    public User() {
        System.out.println("创建对象");
    }

    public void say(){
        System.out.println("我是用户");
    }
}
  • 修改配置文件
<!--4.测试单例多例 通过scope属性控制对象的单例和多例
      scope="prototype" 多例设置
      scope="singleton" 缺省值  单例
-->
   <bean id="user" class="com.jt.pojo.User" scope="prototype"></bean>

1.3 编辑测试方法

@Test
public void testUser(){
    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    context.getBean("user");
    context.getBean("user");
    context.getBean("user");
}

如果是单例模式，那构造方法只会执行一次
如果是多例模式。那构造方法会执行多次

2 懒加载

  • 懒加载:
    • 当用户需要获取对象时,容器才创建对象,称之为懒加载
  • 说明:
    • Spring容器中默认的规则是:容器创建则对象创建.
  • 如果需要配置懒加载 则需要添加额外的属性
<!--4.测试单例多例 通过scope属性控制对象的单例和多例
      scope="prototype" 多例设置
      scope="singleton" 缺省值  单例
      lazy-init="true"  开启懒加载
      lazy-init="false"/lazy-init="default"  懒加载不生效
      原则: 只要是多例对象 都是懒加载. 懒加载只对单例对象有效
      关于懒加载说明: 一般服务器对象应该先行创建,用户直接使用即可.
      多例对象: 用户使用时创建,同时将对象的生命周期交给使用者管理,
               Spring不负责维护对象的生命周期
      (随用随销)
-->
   <bean id="user" class="com.jt.pojo.User" scope="prototype" lazy-init="true"></bean>

3 Spring生命周期

3.1 生命周期的过程:

1.实例化对象

2.初始化操作 (一般对对象的属性赋值)

3.用户使用对象(调用其中的方法)

4.对象销毁 (一般都是释放资源)

3.2 编辑文件

public class User {
    private String conn;//数据库链接

    //1.实例化对象
    public User() {
        System.out.println("创建对象");
    }

    //2.初始化方法
    public void init() {
        this.conn = "赋值数据源链接";
        System.out.println(this.conn);

    }

    //3.用户调用的方法
    public void say() {
        System.out.println("我是用户");
    }

    //4.销毁方法
    public void destory() {
        this.conn = null;
        System.out.println("释放资源" + this.conn + "~~~~");
    }
}

<!--
      测试对象的生命周期
      init-method="init" 初始化方法
      destroy-method="destroy" 销毁方法
-->
   <bean id="user" class="com.jt.pojo.User" init-method="init" destroy-method="destroy"/>

3.3 编辑测试案例

这时ApplicationContext里面没有close方法，我们要使用其子类ClassPathXmlApplicationContext

//测试生命周期运行
@Test
public void testlife(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    //获取对象
    User user = context.getBean(User.class);
    //3.用户调用方法
    user.say();
    //4.只要容器关闭,则对象销毁
    context.close();
}

在这里插入图片描述

3.4 关于IOC小结

核心: 对象的创建

  • 通过bean标签进行创建 属性 id/class
  • 工厂模式
  • 单例多例/懒加载
  • 生命周期

4 依赖注入(DI)

4.1.1 依赖注入介绍

当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在 传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。

对象中的属性 ,应该由spring容器动态赋值.

4.1.2 构建POJO属性

public class User {
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public User() {
    }

    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

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

4.1.3 编辑xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

   <!--管理user对象-->
   <bean id="user" class="com.jt.pojo.User">
      <!--调用对象的set方法实现赋值 set方法必须添加-->
      <property name="id" value="101"></property>
      <property name="name" value="李元芳"></property>
   </bean>
</beans>

4.4.4 测试案例

在这里插入图片描述

4.4.5 关于DI注入说明

  • Set注入
  • 构造注入
<!--构造方法进行注入-->
<bean id="user" class="com.jt.pojo.User">
   <constructor-arg name="id" value="102"/>
   <constructor-arg name="name" value="兰陵王"/>
</bean>

4.2 属性注入高级用法

4.2.1 编辑POJO属性

在这里插入图片描述

4.2.2 编辑xml配置文件

<!--为集合赋值-->
<bean id="user" class="com.jt.pojo.User">
    <property name="id" value="101"/>
    <property name="name" value="李元芳"/>
    <property name="list">
        <list>
            <value>张三</value>
            <value>李四</value>
            <value>王五</value>
        </list>
    </property>
    <property name="set">
        <set>
            <value>1</value>
            <value>2</value>
            <value>3</value>
        </set>
    </property>
    <property name="map">
        <map>
            <entry key="id" value="1000"/>
            <entry key="name" value="tomcat猫"/>
        </map>
    </property>
    <property name="pro">
        <props>
            <prop key="proId">110</prop>
            <prop key="proName">米老鼠</prop>
        </props>
    </property>
</bean>
  • 测试结果

在这里插入图片描述

4.3 抽取集合类型

4.3.1 编辑头标签

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

</beans>

4.3.2 实现对象引用

在这里插入图片描述

  • 测试结果

在这里插入图片描述

5 Spring容器管理3层代码结构

5.1 代码结构

5.1.1 定义User POJO对象

public class User { //通过容器为对象的属性赋值
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

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

5.1.2 定义dao接口/实现类

在这里插入图片描述

5.1.3 定义Service接口/实现类

在这里插入图片描述

5.1.4 编辑UserController

import com.jt.pojo.User;
import com.jt.service.UserService;

public class UserController {
    //spring容器负责注入Service对象
    private UserService userService;
    private User user;//代替用户传入的数据

    public void setUser(User user) {
        this.user = user;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void addUSer(){
        userService.addUser(user);
    }
}

5.1.5 3层代码结构关系

在这里插入图片描述

5.1.6 编辑xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--1.构建user对象-->
    <bean id="user" class="com.jt.pojo.User">
        <property name="id" value="100"/>
        <property name="name" value="springMVC设计模式"/>
    </bean>

    <!--2.构建Dao对象
       根据面向接口编程
          Id:接口的名称
          class:实现类的包路径
    -->
    <bean id="userDao" class="com.jt.dao.UserDaoImpl"/>

    <!--3.构建Service-->
    <bean id="userService" class="com.jt.service.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

    <!--4.构建Controller-->
    <bean id="userController" class="com.jt.controller.UserController">
        <property name="userService" ref="userService"/>
        <property name="user" ref="user"/>
    </bean>
</beans>

5.1.7编辑测试类

public class TestSpring {

    @Test
    public void testSpringMVC(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("application.xml");
        UserController userController = (UserController) context.getBean("userController");
        userController.addUser();
        System.out.println("恭喜学会MVC结构");
    }
}
  • 测试结果

在这里插入图片描述

5.2 关于特殊字符说明

在这里插入图片描述

由于由于业务需要xml配置文件中 可能会有特殊字符,但是该特殊字符与xml关键字(标签)形成冲突，所以我们要 实现字符串转义

  • 特殊转义字符:
    • &lt; 小于<
    • &gt; 大于>
    • &amp; 和号&
    • &apos; 单引号’
    • &quot; 引号"

在这里插入图片描述

  • 万能转义字符: <![CDATA[XXX任意字符]]>

在这里插入图片描述

_-Mr-sun
关注
  • 7
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式——单例模式(懒加载)
Xzg_2017的博客
11-10 3138
这篇文章总结几种比较常用的设计模式，，，不懂得设计模式。。。怎么敢称熟悉OOP思想。单例模式的核心结构中只包含一个被称为单例类的特殊类，通过单例模式可以保证系统中一个类只有一个实例由于快加载单例模式是线程安全的，所以本文只讨论懒加载单例模式的线程安全问题版本一 使用懒加载(快加载)，程序调用时再分配内存，然后初始化class Singleton { public: static S
单例模式之懒加载模式
Android_la的博客
03-12 2737
文章目录一. 问题背景二. 什么是单例模式？三. 为什么要用单例模式？四. 实现单例模式的思路五. 懒汉模式5.1 最简单的懒汉模式5.2 给方法加锁5.3 双重检查锁定5.4 指令重排序5.5 禁止指令重排序 一. 问题背景 公司的电商项目，创建订单的过程中，涉及加载sku信息，又涉及到加载sku库存信息。加载sku库存信息先去缓存查库存，查不到再去数据库，获取到数据再写进缓存。加载sku库存信息这里用到了锁机制，类似于单例懒加载的双重检查机制。锁是用了Redis分布式锁。 笔者对单例懒加载、Redis
设计模式之单例模式的预加载和懒加载实现——懒汉模式和饿汉模式以及如何确保线程安全
一个编程爱好者的博客
03-17 1045
通过单例模式的方法创建的类在当前进程中只有一个实例（根据需要，也有可能一个线程中属于单例，如：仅线程上下文内使用同一个实例）确保一个类中最多只有一个实例，并提供一个全局访问点。即一个类只实例化了一个对象，全局都在使用这一个对象。单例模式的实现由分成了两种情况，饿汉模式和懒汉模式，又叫预加载和懒加载。
常见的单例模式及其实现方式
RdianL的博客
11-20 266
文章目录前言一、什么是单例模式？二、单例模式的实现1.单例模式（饿汉式）1.单例模式（饿汉式）2.读入数据总结 前言 理解多种单例模式的前因后果 提示：以下是本篇文章正文内容，下面案例可供参考 一、什么是单例模式？ 单例模式定义：确保某一个类只有一个实例，并且自行实例化向整个系统提供这个实例。 （独苗） 二、单例模式的实现 1.单例模式（饿汉式） 创建一个单例类需要实现的三步 一个私有的静态变量作为单例对象 私有化构造方法 提供公共的静态获取方法 //1. 饿汉式（静态变量） class Sin
设计模式——单例模式
最新发布
LIUCHANGSHUO的博客
04-13 906
3. 可防止反射攻击和序列化问题：枚举类型的实例在JVM中只会有一个，防止了反射攻击，而且枚举类默认实现了Serializable接口，可以防止序列化问题。这种方式解决上面第三种实现方式的线程不安全问题，具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。
spring_day02_spring_
10-01
标题“spring_day02_spring_”和描述“heima spring source code day 02”表明这是一份关于Spring框架的深入学习资料，主要聚焦在源码分析上，特别是针对第一天学习后的第二天内容。标签“spring”进一步确认了讨论...
day-Spring IoC & DI.md
10-15
- **Core Container**：核心容器，提供 BeanFactory 和 ApplicationContext，用于管理 Bean 的生命周期。 - **Data Access/Integration**：数据访问/集成，提供 Jdbc、ORM、OXM、JMS 等子模块，用于数据库操作和...
day01_eesy_02factory_spring_
09-30
BeanFactory是Spring的基础容器，负责管理bean的生命周期和依赖关系。而ApplicationContext则是在BeanFactory基础上增加了国际化、事件传播、AOP等功能，更常用于实际开发中。 接下来，我们深入到"day01_eesy_02...
spring_day05_spring_
10-01
2. **IoC容器**：IoC（Inversion of Control）是DI的另一种表述，Spring的IoC容器负责创建对象，管理它们的生命周期，以及处理对象间的依赖关系。 3. **AOP（面向切面编程）**：Spring支持AOP，允许开发者定义“切...
spring_day06_spring_
10-03
1. **Spring Core Container**: 这是Spring框架的基础，包含Bean工厂（BeanFactory）和ApplicationContext，负责管理应用对象的生命周期和依赖关系。 2. **Data Access/Integration**: 提供了对JDBC、ORM（Object-...
实现一个懒加载的单例
weixin_35753291的博客
12-29 176
懒汉式单例模式的实现方式是在调用时才创建对象实例，这样就可以延迟对象的创建，从而节省内存空间。 要实现懒汉式单例，需要在类中声明一个静态的对象实例，在调用单例的 getInstance() 方法时，判断对象实例是否已经被创建，如果没有被创建，则创建一个对象实例，并将其保存在静态变量中。 这里是一个示例代码： class LazySingleton { private static LazySing...
单例和多例以及懒加载,注入
weixin_58276266的博客
06-23 505
单例:节省空间, 不会出现线程安全的问题;
java 设计模式-单例模式-懒加载
tiokld的专栏
03-28 7822
首先推荐种最好的单例模式实现方式（没有之一） public class Manager { private Manager() { } public static Manager getInstance() { return ManagerHolder.instance; } private
单例模式下的懒加载问题
kaoguopu7299的博客
12-01 330
转自https://www.cnblogs.com/jingpeipei/p/5771716.html 在开发中，如果某个实例的创建需要消耗很多系统资源，那么我们通常会使用惰性加载机制，也就是说只有当使用到这个实例的时候才会创建这个实例，这个好处在单例模式中得到了广泛应用。这个机制在single-threaded环境下的实现非常简单，然而在multi-threaded环境下却存在隐患。本文重点介绍惰性加载机制以及其在多线程环境下的使用方法。（作者numberzero，参考IBM文章《Double-check
单例模式 懒加载和惰性加载
司少的专栏
08-19 2387
在开发中，如果某个实例的创建需要消耗很多系统资源，那么我们通常会使用惰性加载机制，也就是说只有当使用到这个实例的时候才会创建这个实例，这个好处在单例模式中得到了广泛应用。这个机制在single-threaded环境下的实现非常简单，然而在multi-threaded环境下却存在隐患。本文重点介绍惰性加载机制以及其在多线程环境下的使用方法。（作者numberzero，参考IBM文章《Double-c
单例模式与懒加载方式。
大侠的后花园
12-17 666
单例模式在C++类的设计模式中很普遍。 定义 #define ImplementInstance(cls)\ public:\ static cls* cls::GetInstance()\ {\ static cls* m_pInstance = NULL; \ if (!m_pInstance)\ {\ m_pInstance = new_nothrow cls; ...
单例模式懒加载并发
zdw890412的专栏
11-07 2334
单例虽然没有缓存写的那么平凡，如果在getinstance方法上加sychonize会大大影响性能，单例的写只有在第一使用时才会写。 使用读写锁操作，基本上都上的读锁，对其他线程访问没有影响 public class Singleton { private static Singleton instance = null; private stat
spring 单例多例，默认，懒加载，初始化调用
weixin_33962621的博客
05-20 562
（1）spring 默认是单例， 单例情况下：所有线程对于同一个类共同拥有一个对象，此时如果在类里面创建一个类变量如下 由于所有线程共享一个类对象，所以也共享一个类变量，每次请求都会增加 @Controller @RequestMapping("/user") public class User { private int i=0;//类变量 ...
单例模式（懒加载+线程安全）
baidu_36583119的博客
11-24 1086
我： （1）双重检查 // 单例模式：懒加载+线程安全: 一、双重检查方式 public class SingletonDoubleCheck { // volatile 避免 指令重排序 private static volatile SingletonDoubleCheck instance; private SingletonDoubleCheck(){} // 双重检查 public static synchronized Singlet...
Spring4_day03讲义2: 使用AOP增强DAO权限校验和事务管理
今天的Spring_day03课程主要围绕着引入AOP约束展开，任务包括使用Spring的AOP对客户管理的DAO进行增强以及使用Spring完成转账的事务管理。教学导航中强调掌握Spring的声明式事务和SSH的整合，而教学方法则采用案例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值