当前位置：首页 > news >正文

Spring学习记录

news 2026/5/23 4:18:32

bean的单例与多例设置

工厂模式的三种形态

简单工厂模式

代码：

运行结果：

总结：

工厂模式

代码：

运行结果：

总结：

抽象工厂模式

代码：

运行结果：

总结：

7.Bean的实例化（获取）方式

7.1 通过构造方法实例化

代码：

运行结果：

7.2 通过简单工厂模式实例化

代码：

执行结果：

7.3 通过factory-bean实例化

代码：

运行结果：

7.4 通过FactoryBean接口实例化

代码：

执行结果：

7.5 BeanFactory和FactoryBean的区别【工作面试题！！!】

7.5.1 BeanFactory

7.5.2 FactoryBean

7.6 注入自定义Date

如以下代码：

Student

spring.xml

测试程序

运行结果：

如果把日期格式修改一下：

执行结果：

这种情况下，我们就可以使用FactoryBean来完成这个骚操作。

代码：

编写DateFactoryBean实现FactoryBean接口：

编写spring配置文件：

测试类

运行结果：

bean的单例与多例设置

bean的单例与多例设置 scope属性设置：默认singleton 多例：prototype

默认下：【启动容器的时候就创建对象了】

设置

scope为：prototype【启动容器的时候不会创建对象】【在调getBean才创建】

scope 还有多个值：

工厂模式的三种形态

工厂模式通常有三种形态：

第一种：简单工厂模式（Simple Factory）：不属于23种设计模式之一。简单工厂模式又叫做：静态工厂方法模式。简单工厂模式是工厂方法模式的一种特殊实现。
第二种：工厂方法模式（Factory Method）：是23种设计模式之一。
第三种：抽象工厂模式（Abstract Factory）：是23种设计模式之一。

简单工厂模式

简单工厂模式的角色包括三个：

抽象产品角色
具体产品角色
工厂类角色

代码：

package com.dong.factory;/*** 抽象产品角色*/
public abstract class Weapon {public abstract void attack();
}

package com.dong.factory;/*** 具体产品角色*/
public class Tank extends Weapon{public void attack() {System.out.println("坦克开炮！！！！！");}
}

package com.dong.factory;/*** 具体产品角色*/
public class Warcraft extends Weapon{public void attack() {System.out.println("战斗机扔下小男孩！！！！！");}
}

package com.dong.factory;/*** 工厂类角色*/
public class WeaponFactory {public static Weapon get(String weaponType){if (weaponType==null||weaponType.trim().length()==0) {return null;}Weapon weapon=null;if ("TANK".equals(weaponType)){weapon=new Tank();} else if ("WARCRAFT".equals(weaponType)) {weapon=new Warcraft();}else {throw new RuntimeException("不⽀持该武器！");}return weapon;}
}

package com.dong.factory;/*** 客户端程序*/
public class Test {public static void main(String[] args) {Weapon weapon=WeaponFactory.get("TANK");weapon.attack();Weapon weapon1=WeaponFactory.get("WARCRAFT");weapon1.attack();}
}

运行结果：

总结：

工厂模式

工厂方法模式既保留了简单工厂模式的优点，同时又解决了简单工厂模式的缺点。

工厂方法模式的角色包括：

抽象工厂角色
具体工厂角色
抽象产品角色
具体产品角色

代码：

package com.dong.factory.method;/*** 抽象产品角色*/
public abstract class Weapon {public abstract void attack();
}

package com.dong.factory.method;/*** 具体产品角色*/
public class Dagger extends Weapon{@Overridepublic void attack() {System.out.println("炸军舰。。。。");}
}

package com.dong.factory.method;/*** 具体产品角色*/
public class Gun extends Weapon {@Overridepublic void attack() {System.out.println("开枪射击。。。。");}
}

package com.dong.factory.method;/*** 抽象⼯⼚⻆⾊*/
public abstract class WeaponFactory {public abstract Weapon get();
}

package com.dong.factory.method;/*** 具体⼯⼚⻆⾊*/
public class GunFactory extends WeaponFactory{@Overridepublic Weapon get() {return new Gun();}
}

package com.dong.factory.method;/*** 具体⼯⼚⻆⾊--生产具体产品*/
public class DaggerFactory extends WeaponFactory{@Overridepublic Weapon get() {return new Dagger();}
}

package com.dong.factory.method;/*** 客户端程序*/
public class Test {public static void main(String[] args) {WeaponFactory weaponFactory=new DaggerFactory();Weapon dagger=weaponFactory.get();dagger.attack();WeaponFactory weaponFactory1=new GunFactory();Weapon gun=weaponFactory1.get();gun.attack();}
}

运行结果：

总结：

抽象工厂模式

抽象工厂模式相对于工厂方法模式来说，就是工厂方法模式是针对一个产品系列的，而抽象工厂模式是针对多个产品系列的，即工厂方法模式是一个产品系列一个工厂类，而抽象工厂模式是多个产品系列一个工厂类。
抽象工厂模式特点：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。它有多个抽象产品类，每个抽象产品类可以派生出多个具体产品类，一个抽象工厂类，可以派生出多个具体工厂类，每个具体工厂类可以创建多个具体产品类的实例。每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结果。

抽象工厂中包含4个角色：

抽象工厂角色
具体工厂角色
抽象产品角色
具体产品角色

抽象工厂模式的类图如下：

抽象工厂模式代码如下：

代码：

package com.dong.product;/*** 武器产品族* @author dong* @version 1.0* @className Weapon* @since 1.0**/
public abstract class Weapon {public abstract void attack();
}

package com.dong.product;/*** 武器产品族中的产品等级1* @author dong* @version 1.0* @className Gun* @since 1.0**/
public class Gun extends Weapon{@Overridepublic void attack() {System.out.println("开枪射击！");}
}

package com.dong.product;/*** 武器产品族中的产品等级2* @author dong* @version 1.0* @className Dagger* @since 1.0**/
public class Dagger extends Weapon{@Overridepublic void attack() {System.out.println("砍丫的！");}
}

package com.dong.product;/*** 水果产品族* @author dong* @version 1.0* @className Fruit* @since 1.0**/
public abstract class Fruit {/*** 所有果实都有一个成熟周期。*/public abstract void ripeCycle();
}

package com.dong.product;/*** 水果产品族中的产品等级1* @author dong* @version 1.0* @className Orange* @since 1.0**/
public class Orange extends Fruit{@Overridepublic void ripeCycle() {System.out.println("橘子的成熟周期是10个月");}
}

package com.dong.product;/*** 水果产品族中的产品等级2* @author dong* @version 1.0* @className Apple* @since 1.0**/
public class Apple extends Fruit{@Overridepublic void ripeCycle() {System.out.println("苹果的成熟周期是8个月");}
}

package com.dong.factory;import com.dong.product.Fruit;
import com.dong.product.Weapon;/*** 抽象工厂* @author dong* @version 1.0* @className AbstractFactory* @since 1.0**/
public abstract class AbstractFactory {public abstract Weapon getWeapon(String type);public abstract Fruit getFruit(String type);
}

package com.dong.factory;import com.dong.product.Dagger;
import com.dong.product.Fruit;
import com.dong.product.Gun;
import com.dong.product.Weapon;/*** 武器族工厂* @author dong* @version 1.0* @className WeaponFactory* @since 1.0**/
public class WeaponFactory extends AbstractFactory{public Weapon getWeapon(String type){if (type == null || type.trim().length() == 0) {return null;}if ("Gun".equals(type)) {return new Gun();} else if ("Dagger".equals(type)) {return new Dagger();} else {throw new RuntimeException("无法生产该武器");}}@Overridepublic Fruit getFruit(String type) {return null;}
}

package com.dong.factory;import com.dong.product.*;/*** 水果族工厂* @author dong* @version 1.0* @className FruitFactory* @since 1.0**/
public class FruitFactory extends AbstractFactory{@Overridepublic Weapon getWeapon(String type) {return null;}public Fruit getFruit(String type){if (type == null || type.trim().length() == 0) {return null;}if ("Orange".equals(type)) {return new Orange();} else if ("Apple".equals(type)) {return new Apple();} else {throw new RuntimeException("我家果园不产这种水果");}}
}

package com.dong.client;import com.dong.factory.AbstractFactory;
import com.dong.factory.FruitFactory;
import com.dong.factory.WeaponFactory;
import com.dong.product.Fruit;
import com.dong.product.Weapon;/*** @author dong* @version 1.0* @className Client* @since 1.0**/
public class Client {public static void main(String[] args) {// 客户端调用方法时只面向AbstractFactory调用方法。AbstractFactory factory = new WeaponFactory(); // 注意：这里的new WeaponFactory()可以采用 简单工厂模式 进行隐藏。Weapon gun = factory.getWeapon("Gun");Weapon dagger = factory.getWeapon("Dagger");gun.attack();dagger.attack();AbstractFactory factory1 = new FruitFactory(); // 注意：这里的new FruitFactory()可以采用 简单工厂模式 进行隐藏。Fruit orange = factory1.getFruit("Orange");Fruit apple = factory1.getFruit("Apple");orange.ripeCycle();apple.ripeCycle();}
}

运行结果：

总结：

抽象工厂模式的优缺点：

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在AbstractFactory里加代码，又要在具体的里面加代码。

7.Bean的实例化（获取）方式

Spring为Bean提供了多种实例化方式，通常包括4种方式。（也就是说在Spring中为Bean对象的创建准备了多种方案，目的是：更加灵活）

第一种：通过构造方法实例化
第二种：通过简单工厂模式实例化
第三种：通过factory-bean实例化
第四种：通过FactoryBean接口实例化

7.1 通过构造方法实例化

我们之前一直使用的就是这种方式。默认情况下，会调用Bean的无参数构造方法。

代码：

先配置好各种依赖：

spring.xml【spring6的配置文件】

<?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"><!--spring提供的实例化方式，第一种：在spring配置文件中总结配置类全路径，spring会自动调用该类的无参构造方法来实例化Bean--><bean id="sb" class="com.dong.spring6.bean.SpringBean"/></beans>

maven：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>li.dong</groupId><artifactId>spring6-005-bean-instantiation</artifactId><version>1.0-SNAPSHOT</version><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.9</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope></dependency></dependencies><properties><maven.compiler.source>19</maven.compiler.source><maven.compiler.target>19</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties></project>

package com.dong.spring6.bean;public class SpringBean {public SpringBean() {System.out.println("Spring Bean 的无参构造方法执行。。。。。");}
}

测试：

package com.dong.spring6.test;import com.dong.spring6.bean.SpringBean;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class BeanInstantiationTest {@Testpublic void teatInstantiation(){ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");SpringBean springBean = applicationContext.getBean("sb", SpringBean.class);System.out.println(springBean);}
}

运行结果：

7.2 通过简单工厂模式实例化

代码：

第一步：定义一个Bean

package com.dong.spring6.bean;public class Start {public Start() {System.out.println("Start 无参构造方法正在执行。。。。。");}
}

第二步：编写简单工厂模式当中的工厂类

package com.dong.spring6.bean;/*** 简单工厂模式中的工厂类角色。 星工厂*/
public class StartFactory {public static Start get(){return new Start();}
}

第三步：在Spring配置文件中指定创建该Bean的方法（使用factory-method属性指定）

<?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"><!--spring提供的实例化方式，第一种：在spring配置文件中总结配置类全路径，spring会自动调用该类的无参构造方法来实例化Bean--><bean id="sb" class="com.dong.spring6.bean.SpringBean"/><!--spring提供的实例化方式，第二种：通过简单工厂模式，你需要在spring配置文件中告诉spring框架，调用哪个类的哪个方法获取Bean --><!--factory-method 属性指定的是工厂类当中的静态方法，也就是告诉spring框架，调用这个方法可以获取Bean --><bean id="start" class="com.dong.spring6.bean.StartFactory" factory-method="get"/></beans>

第四步：编写测试程序

package com.dong.spring6.test;import com.dong.spring6.bean.Start;
import com.dong.spring6.bean.StartFactory;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class BeanInstantiationTest {@Testpublic void teatInstantiation2(){ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");Start start = applicationContext.getBean("start", Start.class);System.out.println(start);}
}

teatInstantiation2 方法中的 Start start = applicationContext.getBean("start", Start.class); 中，使用 Start.class 参数是因为 Spring 容器返回的对象类型应该与这里指定的类型保持一致。
虽然在 spring.xml 配置文件中 Bean 的定义指定的是 StartFactory 类并配置了其静态方法 get()，但实际上 Spring 容器会调用该方法并返回一个 Start 类型的实例，这个实例的类型就是由 Spring 自动推断得出的。因此，在 teatInstantiation2 方法中，使用 Start.class 作为参数，表示我们期望获取的是一个 Start 类型的对象，而不是其他类型。

执行结果：

加载spring容器的时候会调用配置的bean的所有无参构造方法

7.3 通过factory-bean实例化

这种方式本质上是：通过工厂方法模式进行实例化。

代码：

第一步：定义一个Bean

package com.dong.spring6.bean;/*** 工厂方法模式中的具体产品角色*/
public class Gun {public Gun() {System.out.println("Gun的无参构造方法执行。。。。。。");}
}

第二步：定义具体工厂类，工厂类中定义实例方法

package com.dong.spring6.bean;/*** 工厂方法模式中的具体工厂角色*/
public class GunFactory {//工厂方法模式中的具体工厂角色中的方法是 实例化方法public Gun get(){return new Gun();}
}

第三步：在Spring配置文件中指定factory-bean以及factory-method

<?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"><!--spring提供的实例化方式，第一种：在spring配置文件中总结配置类全路径，spring会自动调用该类的无参构造方法来实例化Bean--><bean id="sb" class="com.dong.spring6.bean.SpringBean"/><!--spring提供的实例化方式，第二种：通过简单工厂模式，你需要在spring配置文件中告诉spring框架，调用哪个类的哪个方法获取Bean --><!--factory-method 属性指定的是工厂类当中的静态方法，也就是告诉spring框架，调用这个方法可以获取Bean --><bean id="start" class="com.dong.spring6.bean.StartFactory" factory-method="get"/><!--spring提供的实例化方式，第三种：通过工厂方法模式，通过factory-bean属性+factory-method属性共同来完成。--><!--告诉spring框架，调用哪个对象的哪个方法来获取Bean--><bean id="gunFactory" class="com.dong.spring6.bean.GunFactory"/><!--以下配置很关键，factory-bean属性告诉spring调用哪个对象  factory-method属性告诉spring调用该对象的哪个方法。  --><bean id="gun" factory-bean="gunFactory" factory-method="get"/>
</beans>

第四步：编写测试程序

package com.dong.spring6.test;import com.dong.spring6.bean.Gun;
import com.dong.spring6.bean.SpringBean;
import com.dong.spring6.bean.Start;
import com.dong.spring6.bean.StartFactory;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class BeanInstantiationTest {@Testpublic void teatInstantiation(){ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");SpringBean springBean = applicationContext.getBean("sb", SpringBean.class);System.out.println(springBean);}@Testpublic void teatInstantiation2(){ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");Start start = applicationContext.getBean("start", Start.class);System.out.println(start);}@Testpublic void teatInstantiation3(){ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");Gun gun = applicationContext.getBean("gun", Gun.class);System.out.println(gun);}
}

运行结果：

7.4 通过FactoryBean接口实例化

以上的第三种方式中，factory-bean是我们自定义的，factory-method也是我们自己定义的。
在Spring中，当你编写的类直接实现FactoryBean接口之后，factory-bean不需要指定了，factory-method也不需要指定了。
factory-bean会自动指向实现FactoryBean接口的类，factory-method会自动指向getObject()方法。

代码：

第一步：定义一个Bean

package com.dong.spring6.bean;/*** Bean*/
public class Person {public Person() {System.out.println("Person无参构造执行。。。。。");}
}

第二步：编写一个类实现FactoryBean接口

package com.dong.spring6.bean;import org.springframework.beans.factory.FactoryBean;public class PersonFactoryBean implements FactoryBean<Person> {@Overridepublic Person getObject() throws Exception {return new Person();}@Overridepublic Class<?> getObjectType() {return null;}/*** 这个方法在接口中有默认实现。* 默认返回true，表示单例的* 如果想多例，总结总结将这个方法的返回 修改为 return false；即可* @return*/@Overridepublic boolean isSingleton() {return FactoryBean.super.isSingleton();}
}

第三步：在Spring配置文件中配置FactoryBean

<?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"><!--spring提供的实例化方式，第一种：在spring配置文件中总结配置类全路径，spring会自动调用该类的无参构造方法来实例化Bean--><bean id="sb" class="com.dong.spring6.bean.SpringBean"/><!--spring提供的实例化方式，第二种：通过简单工厂模式，你需要在spring配置文件中告诉spring框架，调用哪个类的哪个方法获取Bean --><!--factory-method 属性指定的是工厂类当中的静态方法，也就是告诉spring框架，调用这个方法可以获取Bean --><bean id="start" class="com.dong.spring6.bean.StartFactory" factory-method="get"/><!--spring提供的实例化方式，第三种：通过工厂方法模式，通过factory-bean属性+factory-method属性共同来完成。--><!--告诉spring框架，调用哪个对象的哪个方法来获取Bean--><bean id="gunFactory" class="com.dong.spring6.bean.GunFactory"/><!--以下配置很关键，factory-bean属性告诉spring调用哪个对象  factory-method属性告诉spring调用该对象的哪个方法。  --><bean id="gun" factory-bean="gunFactory" factory-method="get"/><!--spring提供的实例化方式，第四种 ：通过FactoryBean接口来实现。 --><!--这种方式实际上是第三种方式的简化。--><!--由于你编写的类实现了FactoryBean接口，所以这个类是一个特殊的类，不需要你再手动指定：factory-bean、factory-method--><!--通过一个特殊的Bean：工厂Bean，来返回一个普通的Bean Person对象--><!--通过FactoryBean这个工厂Bean主要是想对普通Bean进行加工处理。--><bean id="person" class="com.dong.spring6.bean.PersonFactoryBean"/></beans>

测试程序：

package com.dong.spring6.test;import com.dong.spring6.bean.*;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class BeanInstantiationTest {@Testpublic void teatInstantiation(){ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");SpringBean springBean = applicationContext.getBean("sb", SpringBean.class);System.out.println(springBean);}@Testpublic void teatInstantiation2(){ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");Start start = applicationContext.getBean("start", Start.class);System.out.println(start);}@Testpublic void teatInstantiation3(){ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");Gun gun = applicationContext.getBean("gun", Gun.class);System.out.println(gun);}@Testpublic void teatInstantiation4(){ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");Person person = applicationContext.getBean("person", Person.class);System.out.println(person);}
}

执行结果：

FactoryBean在Spring中是一个接口。被称为“工厂Bean”。“工厂Bean”是一种特殊的Bean。所有的“工厂Bean”都是用来协助Spring框架来创建其他Bean对象的。

7.5 BeanFactory和FactoryBean的区别【工作面试题！！!】

7.5.1 BeanFactory

Spring IoC容器的顶级对象，BeanFactory被翻译为“Bean工厂”，在Spring的IoC容器中，“Bean工厂”负责创建Bean对象。
BeanFactory是工厂。

7.5.2 FactoryBean

FactoryBean：它是一个Bean，是一个能够辅助Spring实例化其它Bean对象的一个Bean。

在Spring中，Bean可以分为两类：

第一类：普通Bean
第二类：工厂Bean（记住：工厂Bean也是一种Bean，只不过这种Bean比较特殊，它可以辅助Spring实例化其它Bean对象。）

7.6 注入自定义Date

我们前面说过，java.util.Date在Spring中被当做简单类型，简单类型在注入的时候可以直接使用value属性或value标签来完成。但我们之前已经测试过了，对于Date类型来说，采用value属性或value标签赋值的时候，对日期字符串的格式要求非常严格，必须是这种格式的：Mon Oct 10 14:30:26 CST 2022。其他格式是不会被识别的。

如以下代码：

Student

package com.dong.spring6.bean;import java.util.Date;/*** @author dong* @version 1.0* @className Student* @since 1.0**/
public class Student {private Date birth;public void setBirth(Date birth) {this.birth = birth;}@Overridepublic String toString() {return "Student{" +"birth=" + birth +'}';}
}

spring.xml

<bean id="studentBean" class="com.dong.spring6.bean.Student"><property name="birth" value="Mon Oct 10 14:30:26 CST 2002"/>
</bean>

测试程序

@Test
public void testDate(){ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");Student studentBean = applicationContext.getBean("studentBean", Student.class);System.out.println(studentBean);
}

运行结果：

如果把日期格式修改一下：

<bean id="studentBean" class="com.dong.spring6.bean.Student"><property name="birth" value="2002-10-10"/>
</bean>

执行结果：

这种情况下，我们就可以使用FactoryBean来完成这个骚操作。

代码：

package com.dong.spring6.bean;import java.util.Date;public class Student {private Date birth;public void setBirth(Date birth) {this.birth = birth;}@Overridepublic String toString() {return "Student{" +"birth=" + birth +'}';}
}

编写DateFactoryBean实现FactoryBean接口：

package com.dong.spring6.bean;import org.springframework.beans.factory.FactoryBean;import java.text.SimpleDateFormat;
import java.util.Date;public class DateFactoryBean implements FactoryBean<Date> {private String strDate;public DateFactoryBean(String strDate) {this.strDate = strDate;}@Overridepublic Date getObject() throws Exception {SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");Date date = simpleDateFormat.parse(strDate);return date;}@Overridepublic Class<?> getObjectType() {return null;}
}

编写spring配置文件：

<?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"><!--通过工厂Bean：DateFactoryBean 来返回普通Bean ：java.util.Date--><bean id="dateFactoryBean" class="com.dong.spring6.bean.DateFactoryBean"><constructor-arg index="0" value="2002-07-01"/></bean><bean id="studentBean" class="com.dong.spring6.bean.Student"><property name="birth" ref="dateFactoryBean"/></bean><!--spring提供的实例化方式，第一种：在spring配置文件中总结配置类全路径，spring会自动调用该类的无参构造方法来实例化Bean--><bean id="sb" class="com.dong.spring6.bean.SpringBean"/><!--spring提供的实例化方式，第二种：通过简单工厂模式，你需要在spring配置文件中告诉spring框架，调用哪个类的哪个方法获取Bean --><!--factory-method 属性指定的是工厂类当中的静态方法，也就是告诉spring框架，调用这个方法可以获取Bean --><bean id="start" class="com.dong.spring6.bean.StartFactory" factory-method="get"/><!--spring提供的实例化方式，第三种：通过工厂方法模式，通过factory-bean属性+factory-method属性共同来完成。--><!--告诉spring框架，调用哪个对象的哪个方法来获取Bean--><bean id="gunFactory" class="com.dong.spring6.bean.GunFactory"/><!--以下配置很关键，factory-bean属性告诉spring调用哪个对象  factory-method属性告诉spring调用该对象的哪个方法。  --><bean id="gun" factory-bean="gunFactory" factory-method="get"/><!--spring提供的实例化方式，第四种 ：通过FactoryBean接口来实现。 --><!--这种方式实际上是第三种方式的简化。--><!--由于你编写的类实现了FactoryBean接口，所以这个类是一个特殊的类，不需要你再手动指定：factory-bean、factory-method--><!--通过一个特殊的Bean：工厂Bean，来返回一个普通的Bean Person对象--><!--通过FactoryBean这个工厂Bean主要是想对普通Bean进行加工处理。--><bean id="person" class="com.dong.spring6.bean.PersonFactoryBean"/></beans>

测试类

package com.dong.spring6.test;import com.dong.spring6.bean.*;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class BeanInstantiationTest {@Testpublic void testDate(){ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");Student student= applicationContext.getBean("studentBean", Student.class);System.out.println(student);}
}

运行结果：

想要输出日期格式为`Student{birth=2002-07-01}`

改进如下：

在 DateFactoryBean 类的 getObject() 方法中，你可以将 SimpleDateFormat 的格式字符串中表示月份的 MM 修改为小写的 mm。此外，为了让喜欢阅读时间戳的人不用再看毫秒和时区信息，可以使用另一个 SimpleDateFormat 对象对日期进行格式化，并返回格式化后的字符串。

修改后的 DateFactoryBean 类如下所示：

public class DateFactoryBean implements FactoryBean<Date> {private String strDate;public DateFactoryBean(String strDate) {this.strDate = strDate;}@Overridepublic Date getObject() throws Exception {SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");return sdf.parse(strDate);}@Overridepublic Class<?> getObjectType() {return Date.class;}@Overridepublic String toString() {SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");return sdf.format(getObject());}
}

然后在 Student 类的 toString() 方法中，调用 DateFactoryBean 对象的 toString() 方法，以获得格式化后的日期字符串。修改后的 Student 类如下所示：

public class Student {private Date birth;public void setBirth(Date birth) {this.birth = birth;}@Overridepublic String toString() {return "Student{" +"birth=" + new DateFactoryBean(birth.toString()) +'}';}
}

这样，在 BeanInstantiationTest 测试类运行后，输出的就是 Student{birth=2002-07-01} 了。

或：

可以使用 SimpleDateFormat，将 birth 格式化成指定格式的字符串，然后输出这个字符串。修改后的 Student 类如下所示：

public class Student {private Date birth;public void setBirth(Date birth) {this.birth = birth;}@Overridepublic String toString() {SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");String birthStr = sdf.format(birth);return "Student{" +"birth=" + birthStr +'}';}
}

【注意：

SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");

】这里的格式：yyyy-MM-dd 月份要大写！！

Student.java 类

package com.dong.spring6.bean;import java.text.SimpleDateFormat;
import java.util.Date;public class Student {private Date birth;public void setBirth(Date birth) {this.birth = birth;}@Overridepublic String toString() {SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");String birthStr=simpleDateFormat.format(birth);return "Student{" +"birth=" + birthStr +'}';}
}

改进后运行结果：

Spring学习记录

目录 bean的单例与多例设置工厂模式的三种形态简单工厂模式代码： 运行结果： 总结： 工厂模式代码： 运行结果： 总结： 抽象工厂模式代码： 运行结果： 总结： …...

编程日记 2023/6/5 9:14:46

模板方法-

定义：又叫模板模式,是指定义一个算法骨架,并允许子类为其中的一个或多个步骤提供实现。适用场景： 1、一次性实现一个算法不变的部分,并将可变的行为留给子类来实现 2、各子类中公共的行为被提取出来并集中到一个公共的父类中,从而避免代码重复优点…...

编程日记 2023/6/5 9:09:45

[Kubernetes] - RabbitMQ学习

1.消息队列消息： 在应用间传送的数据队列，先进先出 1.2. 作用好处：解耦， 容错，削峰坏处：降低系统可用性，系统复杂度提高，一致性问题； RabbitMQ组成部分&#xff1a…...

编程日记 2023/6/5 9:04:43

swagger页面 doc.html出不来，swagger-ui/index.html能出来

swagger页面 doc.html出不来，swagger-ui/index.html能出来。前前后后折腾了很久，jar包冲突，jar包版本，添加路径啥的都弄了，就是出不来。后来全局搜索“doc.html”页面发现能出来的项目能搜到这个页面： 定…...

编程日记 2023/6/5 8:59:42

IEEE802.3和IEEE802.11的分类（仅为分类）

IEEE802.3标准 IEEE802.3:10兆以太网 ●10Base－5 使用粗同轴电缆，最大网段长度为500m，基带传输方法； ●10Base－2 使用细同轴电缆，最大网段长度为185m，基带传输方法； ●10Base&am…...

编程日记 2023/6/5 8:54:41

c# cad二次开发通过获取excel数据在CAD绘图，将CAD属性导出到excel

c# cad二次开发通过获取excel数据在CAD绘图，将CAD属性导出到excel using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.EditorInput; using Autodesk.AutoCAD.Runtime; using System; using System.Collections.Generic; using System.Linq; us…...

编程日记 2023/6/5 8:49:40

LLM之高性能向量检索库

LLM向量数据库高性能向量检索库milvus简介安装调用 faiss简介安装调用高性能向量检索库 milvus 简介 Milvus 是一个开源的向量数据库引擎，旨在提供高效的向量存储、检索和分析能力。它被设计用于处理大规模的高维向量数据，常用于机器学习、计算机视觉…...

编程日记 2023/6/5 8:44:39

实体类注解

目录一、TableField注解二、TableId注解三、Table注解四、TableLogic注解五、Getter与Setter注解六、EqualsAndHashCode注解七、Accessors注解一、TableField注解 Data NoArgsConstructor //空参构造方法 AllArgsConstructor //全参构造方法 TableName("t…...

编程日记 2023/6/5 8:39:38

常见数据结构种类

常见数据结构种类数据存储的常用结构有：栈、队列、数组、链表和红黑树 a.队列（queue） – 先进先出，后进后出。 – 场景：各种排队。叫号系统。 – 有很多集合可以实现队列。 b.栈（stack） – …...

编程日记 2023/6/5 8:34:37

linux高级---k8s中的五种控制器

文章目录一、k8s的控制器类型二、pod与控制器之间的关系三、状态与无状态化对特点四、Deployment1、Deployment的资源清单文件2、在配置清单中调用deployment控制器3、镜像更新4、金丝雀发布5、删除Deployment 五、Statefulset六、DaemonSet1、daemonset的资源清单文件2、在配…...

编程日记 2023/6/5 8:29:35

记一次udp服务性能优化经历

目录概述磁盘io网络io减少重复计算减少内存复制减少互斥锁概述手上有个go项目，接收udp信息（主要是syslog和snmp trap）并查询设备信息，将信息结构化（设备ip名称，匹配了什么规则之类的）后发送…...

编程日记 2023/6/5 8:24:34

uniapp和VueI18n多语言H5项目语言国际化功能搭建流程

uniapp多语言项目国家化功能搭建流程说明：uniapp多语言项目功能搭建分为应用部分和框架部分。应用部分，即开发者自己的代码里涉及的界面部分的语言翻译。框架部分，即uni-app内置组件和API涉及界面的部分的语言翻译。功能的搭建是需要un…...

编程日记 2023/6/5 8:19:32

C# | 凸包算法之Jarvis，寻找一组点的边界/轮廓

C#实现凸包算法之Jarvis 文章目录 C#实现凸包算法之Jarvis前言示例代码实现思路测试结果结束语前言这篇关于凸包算法的文章，本文使用C#和Jarvis算法来实现凸包算法。首先消除两个最基本的问题： 什么是凸包呢？ 凸包是一个包围一组点的凸多…...

编程日记 2023/6/5 8:14:31

SpringBoot接收请求参数的方式

【方式一】原始方式因为SpringBoot封装了Servlet，所以也允许使用HttpServletRequest类中的方法来获取 /*** 【方式一】原始方式*/RequestMapping("/demo01")public String demo01(HttpServletRequest request) {// 参数名要与页面提交的参数名一致Strin…...

编程日记 2023/6/5 8:09:30

MKS SERVO4257D 闭环步进电机_系列5 CAN指令说明

第1部分产品介绍 MKS SERVO 28D/35D/42D/57D 系列闭环步进电机是创客基地为满足市场需求而自主研发的一款产品。具备脉冲接口和RS485/CAN串行接口，支持MODBUS-RTU通讯协议，内置高效FOC矢量算法，采用高精度编码器，通过位置反馈&am…...

编程日记 2023/6/5 8:04:28

安捷伦E4440A（Agilent) e4440a 3HZ-26.5G频谱分析仪

Agilent E4440A、Keysight E4440A、HP E4440A频谱分析仪，3 Hz - 26.5 GHz（PSA 系列） Agilent / Keysight PSA 系列 E4440A 高性能频谱分析仪提供强大的一键式测量、多功能功能集和前沿技术，可满足您的项目和需求。选项可供您选…...

编程日记 2023/6/5 7:59:27

华为OD机试真题 Java 实现【最长子字符串的长度】【2022Q4 100分】，附详细解题思路

一、题目描述给你一个字符串s，字符串s首尾相连组成一个环形，请你在环形中找出‘o’字符出现了偶数次最长子字符串的长度。二、输入描述输入一串小写字母组成的字符串。三、输出描述输出一个整数。四、解题思路题目要求在给定的环形字符串中找出字符’o’出现了…...

编程日记 2023/6/5 7:54:25

【iOS】--对象的底层结构

源码先转一下源码 //#import <Foundation/Foundation.h> #import <objc/runtime.h>interface LGPerson : NSObject property (nonatomic, strong) NSString *KCName; endimplementation LGPersonendint main(int argc, const char * argv[]) {autoreleasepool {…...

编程日记 2023/6/5 7:49:25

高并发内存池设计_内存池

高并发内存池设计 1. 常用的内存操作函数2. 高性能内存池设计_弊端解决之道弊端一弊端二弊端三弊端四3. 弊端解决之道内存管理维度分析内存管理组件选型4. 高并发内存管理最佳实践内存池技术内存池如何解决弊端？高并发时内存池如何实现？5. 高效内存池设计和实现实现思路 (分而…...

编程日记 2023/6/5 7:44:24

给编程初学者的一封信

提醒：以下内容仅做参考，具体请自行设计。随着信息技术的快速发展，编程已经成为一个越来越重要的技能。那么，我们该如何入门编程呢？欢迎大家积极讨论一、自学编程需要注意什么？ 要有足够的时间、精力等…...

编程日记 2023/6/5 7:39:23

8051项目代码流程图工具选择与应用指南

1. 流程图工具概述接手一个大型8051项目时，快速理解代码结构是每个嵌入式工程师都会面临的挑战。我在处理遗留代码时，第一件事就是寻找合适的流程图工具来可视化程序逻辑。市面上确实存在多种能够解析C51代码并生成流程图的软件，但选择时需要…...

编程新知 2026/5/23 4:02:40

MySQL调优实战：MySQL日志机制深入解析，redo/undo/binlog/slow/error日志底层全通透

一、MySQL五大日志总览（全局认知）MySQL 日志严格分为两层：Server层日志 InnoDB引擎层日志。这是90%人混淆的根源：1.1 Server层日志（所有引擎通用）Binlog（二进制日志）：主…...

编程新知 2026/5/23 3:11:27

别再只用Graphics2D了！5个Java图片缩放方案实战评测：从Thumbnailator到OpenCV，谁画质最好？

别再只用Graphics2D了！5个Java图片缩放方案实战评测：从Thumbnailator到OpenCV，谁画质最好？ 当你在Java项目中需要处理用户上传的图片时，是否也遇到过这样的困扰：用Graphics2D简单缩放后，图片变得…...

编程新知 2026/5/23 3:06:35

出海技术团队的沟通挑战：不是语言问题，是文化差异

当软件测试从业者成为“出海先锋”，我们最先打包进行李箱的是什么？是精通JIRA操作，是熟练Python脚本，是深谙CI/CD流水线。我们自信满满，以为能用一口流利的英语、一套标准的ISTQB术语，在全球化的技术团队中…...

编程新知 2026/5/23 2:43:36

STM32F103RCT6国内供应商

在众多STM32F103RCT6的国内供应商中，深圳市粤科源兴科技有限公司以其专业的服务和优质的产品赢得了市场的认可。本文将从产品特性、价格优势以及售后服务等方面详细介绍深圳市粤科源兴科技有限公司为何是您选择STM32F103RCT6的理想合作伙伴。一、产品特性与兼容性产…...

编程新知 2026/5/23 1:18:03

【YOLO全系列架构演进史】2 YOLOv8：解耦头、Anchor-free与多任务统一框架

YOLOv8：解耦头、Anchor-free与多任务统一框架 1.1 总体定位与认知地图 1.1.1.1 我们为什么需要重新理解YOLOv8 YOLOv8在2023年发布时，很多人以为它只是YOLOv5的增量升级。但如果我们把神经网络看作一条工厂流水线，YOLOv8实际上把整条流水线的三个核心工位都换了：原料处理…...

编程新知 2026/5/22 23:35:57

实战测试10款降AIGC软件:只选真正管用的那一款！

随着AI写作工具的普及，论文撰写和内容创作变得前所未有的高效，许多学生和职场人都从中受益。然而，随着AIGC检测技术的不断升级，越来越多的人开始面临新的挑战：原本流畅自然的AI生成内容，如今很容易被系统识…...

编程新知 2026/5/22 23:18:08

Salesforce 扩展“无头”概念至企业数据管理，新架构与系统二季度末或年底推出

分析师提醒分析师表示，此次更新或许能让开发者省去构建 AI 驱动工作流时通常所需的大量集成和定制开发工作，但首席信息官（CIO）们应警惕成本和准确性方面的问题。“无头”概念扩展Salesforce 似乎正致力于“颠覆”企业软件领域。在…...

编程新知 2026/5/22 22:58:40

Flink架构与集群部署（一）

Apache Flink架构Flink组件栈在Flink的整个软件架构体系中，同样遵循这分层的架构设计理念，在降低系统耦合度的同时，也为上层用户构建Flink应用提供了丰富且友好的接口。上图是Flink基本组件栈，从上图可以看出整个Flink的架构体系可…...

编程新知 2026/5/22 22:12:54

平均 CPU 利用率指标为何该摒弃？多个案例揭示真相！

1. 作者信息与文章背景Jeremy Theocharis 是《平凡即卓越》作者、UMH 联合创始人兼首席技术官。文章基于其在 2026 年 4 月云原生亚琛聚会上的演讲，探讨为何应摒弃平均 CPU 利用率指标。2. 应用程序问题引出我们应用程序中的一个 Go 函数在生产环境总是被取消执行。…...

编程新知 2026/5/22 21:40:52

bean的单例与多例 设置

工厂模式的三种形态

简单工厂模式

代码：

运行结果：

总结：

工厂模式

代码：

运行结果：

总结：

抽象工厂模式

代码：

运行结果：

总结：

7.Bean的实例化（获取）方式

7.1 通过构造方法实例化

代码：

运行结果：

7.2 通过简单工厂模式实例化

代码：

执行结果：

7.3 通过factory-bean实例化

代码：

运行结果：

7.4 通过FactoryBean接口实例化

代码：

执行结果：

7.5 BeanFactory和FactoryBean的区别 【工作面试题！！!】

7.5.1 BeanFactory

7.5.2 FactoryBean

7.6 注入自定义Date

如以下代码：

Student

spring.xml

测试程序

运行结果：

如果把日期格式修改一下：

执行结果：

这种情况下，我们就可以使用FactoryBean来完成这个骚操作。

代码：

编写DateFactoryBean实现FactoryBean接口：

编写spring配置文件：

测试类

运行结果：

想要输出日期格式为Student{birth=2002-07-01}

Student.java 类

改进后运行结果：

相关文章：

bean的单例与多例设置

7.5 BeanFactory和FactoryBean的区别【工作面试题！！!】

想要输出日期格式为`Student{birth=2002-07-01}`