public class MyFactoryBean implements FactoryBean<Connection> {
  // 用于书写创建复杂对象的代码，并且把复杂对象作为方法的返回值返回
  @Override
  public Connection getObject() throws Exception {
    Class.forName("com.mysql.jdbc.Driver");
    Connection connection = DriverManager.getConnection("jdbc:mysql:///javaweb?characterEncoding=utf-8&useSSL=false","root","123456");
    return connection;
  }
  // 返回所创建的复杂对象的Class对象
  @Override
  public Class<?> getObjectType() {
    return Connection.class;
  }
  // 配置是否是单例模式
  @Override
  public boolean isSingleton() {
    return false;
  }
复制代码

<bean id="factoryBean" class="com.test.MyFactoryBean">
复制代码

/**
  * 用于测试factoryBean
  */
  @Test
  public void testFactoryBean(){
    ClassPathXmlApplicationContext ctr = new ClassPathXmlApplicationContext("/applicationContext.xml");
    Connection conn  = (Connection) ctr.getBean("factoryBean");
    System.out.println(conn);
  }
复制代码

import java.sql.Connection;
import java.sql.DriverManager;
import org.springframework.beans.factory.FactoryBean;
/**
 * @Description
 * @Author XiaoLin
 * @Date 2021/2/24 19:47
 */
public class MyFactoryBean implements FactoryBean<Connection> {
  @Override
  public Connection getObject() throws Exception {
    Class.forName("com.mysql.jdbc.Driver");
    Connection connection = DriverManager
        .getConnection("jdbc:mysql:///javaweb?characterEncoding=utf-8&useSSL=false", "root",
            "1101121833");
    return connection;
  }
  @Override
  public Class<?> getObjectType() {
    return Connection.class;
  }
  @Override
  public boolean isSingleton() {
    return true;
  }
}
复制代码

<?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 id="factoryBean" class="MyFactoryBean">
  </bean>
</beans>
复制代码

import java.sql.Connection;
import org.junit.Test;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @Description
 * @Author XiaoLin
 * @Date 2021/2/24 19:50
 */
public class MyFactoryBeanTest {
  /**
  * 用于测试复杂类型对象的创建
  */
  @Test
  public void testMyFactoryBeanTest(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/applicationContext.xml");
    MyFactoryBean connection = (MyFactoryBean)applicationContext.getBean("&factoryBean");// 获取普通的简单对象FactoryBean，不获取复杂的Connection对象
    System.out.println(connection);
  }
}
复制代码

// 实例工厂
public class ConnectionFactory {
  public Connection getConnection(){
    Connection conn = null;
    try {
      Class.forName("com.mysql.jdbc.Driver");
      conn = DriverManager.getConnection("jdbc:mysql:///javaweb?characterEncoding=utf-8&useSSL=false","root","1101121833");
    } catch (ClassNotFoundException | SQLException e) {
      e.printStackTrace();
    }
   return conn;
  }
}
复制代码

<bean id="connFactory" class="com.factory.ConnectionFactory"/>
  <bean id="conn" factory-bean="connFactory" factory-method="getConnection"/>
复制代码

public class ConnectionStaticBeanFactory {
  public static Connection getConnection(){
    Connection conn = null;
    try {
      Class.forName("com.mysql.jdbc.Driver");
      conn = DriverManager.getConnection("jdbc:mysql:///javaweb?characterEncoding=utf-8&useSSL=false","root","1101121833");
    } catch (ClassNotFoundException | SQLException e) {
      e.printStackTrace();
    }
    return conn;
  }
}
复制代码

<bean id="staticBeanFactory" class="com.factory.ConnectionStaticBeanFactory" factory-method="getConnection"/>
复制代码

<bean id="person" scope="singleton(prototype)"  class="com.doamin.Person"/>
复制代码

// 这个就是初始化方法，做一些初始化操作，Spring会进行调用 
@Override
  public void afterPropertiesSet() throws Exception {
    // 初始化操作
  }
复制代码

public void init(){
    System.out.println("我是初始化方法");
  }
复制代码

<bean id="product" class="com.domain.Product" init-method="init"/>
复制代码

public class Product implements InitializingBean, DisposableBean {
      @Override
  public void destroy() throws Exception {
    System.out.println("销毁操作，资源释放");
  }
}
复制代码

public class Product implements InitializingBean, DisposableBean { 
  public void MyDestory(){
      System.out.println("自己定义的销毁方法");
    }
}
复制代码

<bean id="product" class="com.domain.Product" destroy-method="MyDestory"/>
复制代码

<!--告诉Spring你的db.properties在哪里-->  
<context:property-placeholder location="classpath:/db.properties"/>
<!--用$(db.properties中的key)来进行取值-->
<bean id="conn" class="com.factory.BeanFactory">
  <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>
复制代码

@Data
@AllArgsConstructor
@NoArgsConstructor
public class People {
  private String name;
  private Date birthday;
}
复制代码

<bean id="people" class="com.domain.People">
    <property name="name" value="XiaoLin"/>
    <property name="birthday" value="2021-2-6"/>
  </bean>
复制代码

Caused by: java.lang.IllegalStateException: Cannot convert value of type 'java.lang.String' to required type 'java.util.Date' for property 'birthday': no matching editors or conversion strategy found
  at org.springframework.beans.TypeConverterDelegate.convertIfNecessary(TypeConverterDelegate.java:262)
  at org.springframework.beans.AbstractNestablePropertyAccessor.convertIfNecessary(AbstractNestablePropertyAccessor.java:585)
  ... 39 more
复制代码

public class MyConverter implements Converter<String, Date> {// 他有两个泛型，一个是转换前的类型，另一个是转换后的类型
  /*
  convert方法的作用是将String->Date
  parm:source代表的是配置文件中需要转换的内容
  return:把转换好的值作为返回值，Spring会自动为属性赋值
   */
  @Override
  public Date convert(String source) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Date parse = null;
    try {
      parse = sdf.parse(source);
    } catch (ParseException e) {
      e.printStackTrace();
    }
    return parse;
  }
}
复制代码

<!--  类型转换器的注册，告诉Spring我们所创建的MyConverter类是类型转换器类，
      Spring提供了一个类ConversionServiceFactoryBean来完成类型转换器的注册-->
  <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters" >
      <set>
<!--        注册类型转换器-->
        <ref bean="myConvert"/>
      </set>
    </property>
  </bean>
复制代码

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
  private Integer id;
  private String name;
}
复制代码

public class  MyBeanPoster implements BeanPostProcessor  {
  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName)
      throws BeansException {
    return bean;
  }
  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    // 要进行类型判断，如果不是Student类型的话直接返回，不然会报类型转换错误，因为Spring会把工厂中的所有对象进行加工处理
    if (bean instanceof Student){
      Student student = (Student) bean;
      student.setName("lisi");
    }
    return bean;
  }
}
复制代码

<bean id="student" class="com.beanpost.Student">
    <property name="id" value="10"/>
    <property name="name" value="zs"/>
  </bean>
<!--注册后置Bean-->
  <bean id="myBeanProcessor" class="com.beanpost.MyBeanPoster"/>