[学习笔记] Spring-DI

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量291 收藏
点赞数
分类专栏： Java Spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FE_Fighter/article/details/98126964
版权
Java 同时被 2 个专栏收录
14 篇文章 0 订阅
订阅专栏
Spring
3 篇文章 0 订阅
订阅专栏

文章目录

依赖注入

Spring Ioc简单来讲就是让spring框架(或者说容器, 工厂)帮我们创建bean, 而DI(依赖注入)则是spring帮我们注入属性

注入是什么意思? 简单来讲就是给对象设置值

注入的方式:

  • 方式1: 调用对象的setter方法
  • 方式2: 创建对象时(即调用对象构造器时)设置对象的属性值

xml自动装配(不推荐)

自动装配对应bean元素的autowire属性, 让spring按照一定的规则自己去找对应的对象, 并完成DI操作.

可选值有:

  • default: 不要自动注入, 相当于no
  • no: 不要自动注入
  • byName: 按照属性的id在spring中寻找bean, 类似factory.getBean(String beanName);
  • byType: 按照依赖对象的类型注入, 类似factory.getBean(Class requiredType)
  • constructor: 按照对象的构造器上面的参数类型注入

bean:

package _02_DI._01_xml_autowire;

public class SomeBean {
	
	private OtherBean otherBean;

	public void setOtherBean(OtherBean otherBean) {
		this.otherBean = otherBean;
	}
	@Override
	public String toString() {
		return "SomeBean [otherBean=" + otherBean + "]";
	}
}

class OtherBean {
	
}

配置文件:

	<bean id="otherBean" class="_02_DI._01_xml_autowire.OtherBean" />
	<bean id="someBean" class="_02_DI._01_xml_autowire.SomeBean" autowire="byType" />

测试代码:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:_02_DI/_01_xml_autowire/AppTest.xml")
public class App {
	
	@Autowired
	private SomeBean someBean;
	
	@Test
	public void testXmlAutoWire() throws Exception {
		System.out.println(someBean);
	}
}

通过setter方法注入

使用bean元素中的property子元素, 通过对象的setter方法完成设置操作

注入值类型:

  • 常量值(简单类型), value属性
  • 对象, ref属性
  • 集合, 对应集合类型元素

value属性给简单类型设置值

bean:

package _02_DI._02_setter_wire;

public class Obj {
	private String name;
	private Integer age;

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

	@Override
	public String toString() {
		return "Obj [name=" + name + ", age=" + age + "]";
	}
}

xml:

	<bean id="obj" class="_02_DI._02_setter_wire.Obj">
		<property name="name">
			<value>Fighter</value>
		</property>
		
		<property name="age" value="21" />
	</bean>

注意:

  • name属性的值是bean中被注入的属性的名称; value属性(value子元素)的值是被注入的值
  • 两种设置值的方式等价
  • 传入时都传入的是字符串, spring会自动转换类型

测试代码:

	@Autowired
	private Obj obj;
	
	@Test
	public void test01() throws Exception {
		System.out.println(obj);
	}

ref属性给对象类型设置值

bean:

package _02_DI._02_setter_wire._02_obj_setter;

public class Obj {
	private Wired wired;

	public void setWired(Wired wired) {
		this.wired = wired;
	}

	@Override
	public String toString() {
		return "Obj [wired=" + wired + "]";
	}
}

class Wired {

}

xml:

	<bean id="wired" class="_02_DI._02_setter_wire._02_obj_setter.Wired" />
	<bean id="obj" class="_02_DI._02_setter_wire._02_obj_setter.Obj">
		<property name="wired" ref="wired" />
	</bean>

ref属性与被注入的对象的id属性相同

给集合类型设置值

bean:

package _02_DI._02_setter_wire._03_collection_wire;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class CollectionBean {
	private Set<String> s;
	private List<String> l;
	private String[] array;
	private Map<String, String> map;
	private Properties p;
	
	public void setS(Set<String> s) {
		this.s = s;
	}
	public void setL(List<String> l) {
		this.l = l;
	}
	public void setArray(String[] array) {
		this.array = array;
	}
	public void setMap(Map<String, String> map) {
		this.map = map;
	}
	public void setP(Properties p) {
		this.p = p;
	}

	@Override
	public String toString() {
		return "CollectionBean [\ns=" + s + ", \nl=" + l + ", \narray="
				+ Arrays.toString(array) + ", \nmap=" + map + ", \np=" + p + "\n]";
	}
}

配置文件:

<bean id="cb" class="_02_DI._02_setter_wire._03_collection_wire.CollectionBean">
		<!-- 给属性注入值一律用property子元素 -->
		<property name="s">
			<set>
				<value>set1</value>
				<value>set2</value>
			</set>
		</property>
		
		<property name="l">
			<list>
				<value>list1</value>
				<value>list2</value>
			</list>
		</property>
		
		<property name="array">
			<array>
				<value>array1</value>
				<value>array2</value>
			</array>
		</property>
		
		<property name="map">
			<map>
				<entry key="key1" value="value1" />
				<entry key="key2" value="value2" />
			</map>
		</property>
		
		<property name="p">
			<value>
				p1=v1
				p2=v2
			</value>
		</property>
	</bean>

说明:

  • 给属性注入值一律用property子元素, 不管是简单类型还是对象类型还是集合类型
  • map类型由键值对组成, 所以需要使用entry子元素, 在entry中设置key和value
  • properties类型其实本质上属于map类型, 所以使用和map一样的注入方式也是可以的. 但更推荐使用演示的这种写法
  • 经过测试, 发现set, list和array这三个其实是可以乱用的, 原因查明了再回来补, 留个坑

构造器注入

以上演示的是setter方法注入, 底层调用对象的setter方法, 下面的案例演示通过构造器注入(bean不用提供setter方法)

setter注入使用的是<property>元素, 表示bean的属性; 而构造器注入使用的是<constructor-arg>元素

构造器注入有多钟方式, 如按照默认顺序, 使用index, 使用type等, 但不推荐, 推荐使用name, 与<property>元素里的name一样代表属性的名字, 下面案例很容易看懂其用法

bean:

package _02_DI._02_setter_wire._04_constructor_setter;

import java.util.List;
import java.util.Properties;

public class Bean {
	private String name;
	private Integer age;
	private OtherBean otherBean;
	private List<String> list;
	private Properties p;

	public Bean(String name, Integer age, OtherBean otherBean,
			List<String> list, Properties p) {
		this.name = name;
		this.age = age;
		this.otherBean = otherBean;
		this.list = list;
		this.p = p;
	}

	@Override
	public String toString() {
		return "Bean [name=" + name + ", age=" + age + ", otherBean="
				+ otherBean + ", list=" + list + ", p=" + p + "]";
	}
}

class OtherBean{
	
}

配置文件:

	<bean id="ob" class="_02_DI._02_setter_wire._04_constructor_setter.OtherBean" /> 
	<bean id="bean" class="_02_DI._02_setter_wire._04_constructor_setter.Bean">
		<constructor-arg name="name" value="Fighter" />
		<constructor-arg name="age" value="21" />
        
		<constructor-arg name="otherBean" ref="ob" />
        
		<constructor-arg name="list">
			<list>
				<value>list1</value>
				<value>list2</value>
			</list>
		</constructor-arg>
        
		<constructor-arg name="p">
			<value>
				k1=v1
				k2=v2
			</value>
		</constructor-arg>
	</bean>

bean元素的继承

先看一下这个案例(普通的bean注入的演示):

bean:

package _02_DI._03_inheritance;

public class Bean1 {
	private String name;
	private Integer age;
	private Integer id;
	
	public void setName(String name) {
		this.name = name;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	
	@Override
	public String toString() {
		return "Bean1 [name=" + name + ", age=" + age + ", id=" + id + "]";
	}
}
//---------------------------------------------
package _02_DI._03_inheritance;

public class Bean2 {
	private String name;
	private Integer age;
	private String color;
	
	public void setName(String name) {
		this.name = name;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public void setColor(String color) {
		this.color = color;
	}
	
	@Override
	public String toString() {
		return "Bean2 [name=" + name + ", age=" + age + ", color=" + color
				+ "]";
	}
}

这里有两个bean, 两者都有name属性和age属性

配置文件:

	<bean id="bean1" class="_02_DI._03_inheritance.Bean1">
		<property name="name" value="Fighter" />
		<property name="age" value="21" />
		<property name="id" value="201603775" />
	</bean>

	<bean id="bean2" class="_02_DI._03_inheritance.Bean2">
		<property name="name" value="Fighter" />
		<property name="age" value="21" />
		<property name="color" value="deepskyblue" />
	</bean>

可以发现, 两个bean的两个属性是一样的, 而且值也一样, 这样就可以把相同的地方抽取出来

现在配置文件应该这样写:

	<bean id="base_bean" abstract="true">
		<property name="name" value="Fighter" />
		<property name="age" value="21" />
	</bean>

	<bean id="bean1" class="_02_DI._03_inheritance.Bean1" parent="base_bean">
		<property name="id" value="201603775" />
	</bean>

	<bean id="bean2" class="_02_DI._03_inheritance.Bean2" parent="base_bean">
		<property name="color" value="deepskyblue" />
	</bean>

说明:

  • abstract="true"表示spring不需要为我们创建对象
  • bean的继承和java继承不一样, bean继承是把相同的代码抽取出来, 相当于一段xml代码的拷贝
  • bean元素的parent属性表示继承于哪一个bean

配置数据库连接池

之前给数据库连接池设置连接四要素时是这样设置的(以druid为例):

public class App {
	
	private DruidDataSource ds;
	
	@Test
	public void test01() throws Exception {
		ds = new DruidDataSource();
		ds.setDriverClassName("com.mysql.jdbc.Driver");
		ds.setUrl("jdbc:mysql://localhost:3306/jdbcdemo");
		ds.setUsername("root");
		ds.setPassword("1092568516");
		Connection conn = ds.getConnection();
        ...
	}
}

观察一下可以发现, 创建连接池对象实际上就是new出来一个连接池, 然后给它设置属性

现在我们交给spring帮我们管理连接池:

配置文件:

	<bean id="ds" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/jdbcdemo" />
		<property name="username" value="root" />
		<property name="password" value="1092568516" />
	</bean>

测试代码:

	@Autowired
	private DruidDataSource ds;
	
	@Test
	public void test01() throws Exception {
		Connection conn = ds.getConnection();
        ...
	}

但是上述代码耦合度太高了, 应该把连接数据库的四要素写在properties文件里面, 方便维护(比如哪天不用MySql而用用其他数据库, 不用修改源代码), 然后让xml配置文件加载properties文件
properties文件:

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcdemo
username=root
password=1092568516

现在就该让xml配置文件读取properties文件了:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!-- 加载db.properties配置文件 -->    
    <context:property-placeholder location="classpath:db.properties" />

	<bean id="ds" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="${driverClassName}" />
		<property name="url" value="${url}" />
		<property name="username" value="${username}" />
		<property name="password" value="${password}" />
	</bean>
	
</beans>

一运行会发现报错, 原因是因为java中当前系统账户的属性也叫username, 为避免冲突, 在properties文件中所有key值前加上jdbc.

新的properties:

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/jdbcdemo
jdbc.username=root
jdbc.password=1092568516

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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!-- 加载db.properties配置文件 -->    
    <context:property-placeholder location="classpath:db.properties" />

	<bean id="ds" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
	
</beans>

现在就没问题了

注册测试案例

到这里IoC和DI差不多就这些了, 下面讲一个注册的案例, 将之前的知识点融合一下

domain类:

package _02_DI._05_register.domain;

@Getter@Setter@toString
public class User {
	private Long id;
	private String username;
	private int age;

新建dao包, 包下新建IUserDao接口和其实现类:

package _02_DI._05_register.dao;

import _02_DI._05_register.domain.User;

public interface IUserDao {
	void save(User u);
}

package _02_DI._05_register.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import javax.sql.DataSource;

import _02_DI._05_register.dao.IUserDao;
import _02_DI._05_register.domain.User;

public class UserDaoImpl implements IUserDao {

	private DataSource ds;
	public void setDs(DataSource ds) {
		this.ds = ds;
	}

	public void save(User u) {
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			conn = ds.getConnection();
			String sql = "INSERT INTO `t_student` (sname, age) VALUE (?, ?)";
			ps = conn.prepareStatement(sql);
			ps.setString(1, u.getUsername());
			ps.setInt(2, u.getAge());
			ps.executeUpdate();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally{
			if(ps != null){
				try {
					ps.close();
				} catch (SQLException e) {
					e.printStackTrace();
				} finally{
					if(conn != null){
						try {
							conn.close();
						} catch (SQLException e) {
							e.printStackTrace();
						} 
					}
				}
			}
		}
	}

}

然后在xml配置文件中配置数据库连接池和dao的bean:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!-- 加载db.properties配置文件 -->    
    <context:property-placeholder location="classpath:db.properties" />

	<bean id="ds" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>
	
	<bean id="userDao" class="_02_DI._05_register.dao.impl.UserDaoImpl">
		<property name="ds" ref="ds" />
	</bean>

</beans>

新建service包, 包下新建IUserService接口和其实现类, 实现类中调用dao中的save方法

package _02_DI._05_register.service;

import _02_DI._05_register.domain.User;

public interface IUserService {
	void Register(User u);
}

package _02_DI._05_register.service.impl;

import _02_DI._05_register.dao.IUserDao;
import _02_DI._05_register.domain.User;
import _02_DI._05_register.service.IUserService;

public class UserServiceImpl implements IUserService {

	IUserDao userDao;
	public void setUserDao(IUserDao userDao) {
		this.userDao = userDao;
	}

	public void Register(User u) {
		userDao.save(u);
	}

}

配置文件中添加service的配置:

	<bean id="userService" class="_02_DI._05_register.service.impl.UserServiceImpl">
		<property name="userDao" ref="userDao" />
	</bean>

新建action包, 包下新建UserAction类, 调用service的register方法:

package _02_DI._05_register.action;

import _02_DI._05_register.domain.User;
import _02_DI._05_register.service.IUserService;

public class UserAction {

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

	public String execute(){
		userService.Register(new User());
		return "Success";
	}
}

配置文件添加action的bean配置:

	<bean id="userAction" class="_02_DI._05_register.action.UserAction">
		<property name="userService" ref="userService" />
	</bean>

测试代码, 注入UserAction类, 调用其execute方法, execute方法会调用service的register方法, service会调用dao的save方法:

package _02_DI._05_register;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import _02_DI._05_register.action.UserAction;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:_02_DI/_05_register/AppTest.xml")
public class App {
	
	@Autowired
	private UserAction userAction;
	
	@Test
	public void testDao(){
		userAction.execute();
	}
}

最后运行成功, 但数据库新增的一行中没有数据(因为没有给User设置属性)

FE_Fighter
关注
专栏目录
【学习笔记】Spring-IOC-DI-AOP 学习笔记
straker的博客
01-24 309
文章目录1.Spring学前基础依赖maven中jar包依赖的传递性SHA1算法Hash相关知识Hash碰撞数据传输安全保证build标签maven常用命令1. clean指令2.compile指令3.install指令项目发布命令2.Spring-IOC面向接口编程Spring-IOC介绍1.XML开发2.Spring创建对象的步骤！！！重要！！！3.注解开发Spring中多例模式@ScopeSpring中的懒加载Spring的生命周期注解总结Spring执行步骤！！！！3.Spring依赖注入（DI）依
Spring学习笔记——DI
weixin_44802953的博客
07-26 111
五、DI（依赖注入） DI和IOC其实描述的是一个概念，只是站在不同角度去描述，也可以说DI是IOC的技术实现，Spring使用反射机制底层创建对象。当Teacher要调用Student时，Spring容器会创建Student的对象，Teacher通过Spring容器获取所需要的Student的实例对象，就叫做依赖注入。 依赖注入主要有两种实现方法： 1.属性setter注入 Ioc容器使用setter方法注入被依赖的实例。通过调用无参构造器或无参static工厂方法实例化bean后，调用该bean的set
Spring-Smart-DI
十四 丶
10-14 181
用注解的方式动态切换实现类实现方式。 比如我们有多个消息中间件或多个短信服务商，需要动态切换的时候，无需自己写判断逻辑来进行服务商的切换。只用一套注解就可以解决问题
Spring学习笔记--DI
Aaaabt的博客
06-29 120
Spring学习笔记–DI 依赖注入 构造器注入(在IOC篇已讲过) Setter方式注入 依赖注入：Set注入 依赖：bean对象的创建依赖于容器 注入：bean对象中的所有属性，由容器来注入 实体类： public class Student { private String name; private Address address; private String[] books; private List<String> hobbys;
Spring-尚硅谷-学习笔记
weixin_45581692的博客
10-10 6715
Spring框架是一个轻量级的开源的JavaEE框架。 Spring可以解决企业应用开发的复杂性。 Spring有两个核心部分：IOC和AOP IOC：控制反转，把创建对象的过程交给Spring AOP：面向切面，不修改源代码的情况下进行功能增强 Spring特点 方便解耦，简化开发 AOP编程支持 方便程序测试 方便和其他框架进行整合
Spring -学习笔记
meini32的博客
08-28 480
Spring 是一个开源的企业级应用程序开发框架，它为 Java 应用程序提供了全面的基础设施支持和丰富的功能模块。Spring 的目标是简化 Java 开发，提高开发效率、代码质量和可维护性。解决企业级应用开发的复杂性而存在；Spring的核心是提供一个容器。这个容器会创建和管理应用的组件，组件称为Bean，通过这个容器将bean装配在一起，形成一个完整的应用程序。容器称为Spring应用上下文；将bean组装在一起的行为是通过依赖注入DI的模式实现；让JavaBean之间进行更有效的。
Spring学习笔记 --Spring基础介绍
qq_37779333的博客
05-24 255
**概要：**说起Spring，作为java开发程序员必备技能，掌握Spring常用开发技术点是必须的。包含DI IOC AOP思想。Spring全家桶（boot cloud security等）. Spring 框架是一个开源的 Java 平台，它最初是由 Rod Johnson 编写的， 并且于 2003 年 6 月首次在 Apache 2.0 许可下发布。 Spring 是轻量级的框架，其基...
Spring学习笔记---上篇
weixin_46625488的博客
06-26 468
Spring中IOC介绍和学习
Spring学习笔记---IOC与DI
rosinante
05-28 358
目录 传统方式建立一个对象： 1.最原始方法： 2..面向接口方法： 3.工厂模式 4.工厂+反射+配置文件 实现程序解耦 将实现类交给Spring管理 1.编写配置文件applicationContext.xml 2.编写测试类 SpringIOC与DI 1.springIOC与DI的关系 2.如何理解DI 3.如何使用DI 传统方式建立一个对象： 1.最原...
spring学习笔记03-spring-DI-依赖注入详解（通过xml配置文件来配置依赖注入）
qq_33820545的博客
02-16 150
spring学习笔记03-spring-DI-依赖注入详解 1.概念 2.构造函数注入 3.set方法注入 4.集合的注入 需要被注入的实体对象 package com.itheima.service.impl; import com.itheima.service.IAccountService; import java.util.Arrays; import java.util.List;...
spring-analysis-master.zip
12-05
总结，Spring框架的深度分析涵盖了其核心模块、Web开发、数据访问、事务管理等多个方面，通过学习和理解这些组件，开发者可以更好地运用Spring来构建高效、可维护的大型企业级应用。同时，Spring Boot和Spring Cloud...
spring-microservices-in-action-note:Spring微服务的实践学习笔记
03-16
《Spring微服务实战笔记》是基于Java开发领域的深度学习资源，专注于Spring框架在构建微服务架构中的应用。本文将深入探讨Spring微服务的核心概念、关键技术和最佳实践。 1. **Spring框架基础**：Spring框架是Java...
spring-framework-5.2.3.RELEASE.rar
03-14
这些文档通常包括API参考、用户指南和开发者笔记，是学习和解决问题的重要资源。 为了快速搭建Spring Framework，你需要做以下几步： 1. **解压文件**：首先，解压缩"spring-framework-5.2.3.RELEASE.rar"，获取所...
Spring学习笔记----Spring Framework体系结构及内部各模块jar之间的maven依赖关系
Vivienne_ChenW的博客
08-01 816
一、目前的问题 在 Spring Boot 出现之前，Spring开发java项目，当配置maven依赖的时候并不能知道要配置哪些spring的jar，经常是胡乱添加一堆，编译或运行报错就继续配置jar依赖，导致spring依赖混乱。甚至下一次创建相同类型的工程时也不知道要配置哪些spring的依赖，还是拷贝之前的，导致maven越来越乱，还容易出错。 为何需要添加这些依赖？各依赖之间有何关系？某个依赖是否可以省略？要回答这些问题，就有必要了解 Spring 的依赖体系。 二、应用 spring的jar包只
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 287
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 823
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 891
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 266
默认对常规Session的理解和使用，如何使用Set-Cookie。
spring6 笔记(3 万字详解)
2301_79083000的博客
10-29 1283
尚硅谷spring笔记带你一套掌握spring
Spring 2.5 整合与AOP实践学习笔记
"Spring2.5 学习笔记" 在学习Spring 2.5的过程中，我们需要理解这个版本的核心特性，特别是依赖注入（Dependency Injection, DI）和面向切面编程（Aspect-Oriented Programming, AOP）。以下是对每个章节的详细解释...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值