Spring（全网最详细）值得收藏

整个框架支持的最低JDK版本直接跨越到 JDK17。

Servlet、JPA 等从javax迁移到jakarta命名空间。

兼容jakarta EE 9 、jakarta EE 10。

支持AOT技术。

浪费资源：StudentService调用方法时即会创建一个对象，如果不断调用方法则会创建大量StudentDao对象。

代码耦合度高：假设随着开发，我们创建了StudentDao另一个更加完善的实现类StudentDaoImpl2，如果在StudentService中想使用StudentDaoImpl2，则必须修改源码。

创建实体类

public class Student {
private int id;
private String name;
private String address;
// 省略getter/setter/构造方法/tostring
}

创建Dao接口和实现类

public interface StudentDao {
// 根据id查询学生
Student findById(int id);
}

public class StudentDaoImpl implements StudentDao {
@Override
public Student findById(int id) {
// 模拟从数据库查找出学生
return new Student(1,\”百战程序员\”,\”北京\”);
}
}

public class StudentDaoImpl2 implements StudentDao {
@Override
public Student findById(int id) {
// 模拟从数据库查找出学生
System.out.println(\”新方法！！！\”);
return new Student(1,\”百战程序员\”,\”北京\”);
}
}

创建配置文件bean.properties，该文件中定义管理的对象

studentDao=com.itbaizhan.dao.impl.StudentDaoImpl

创建容器管理类，该类在类加载时读取配置文件，将配置文件中配置的对象全部创建并放入容器中。

public class Container {
static Map<String,Object> map = new HashMap<>();
static {
// 读取配置文件
InputStream is = Container.class.getClassLoader().getResourceAsStream(\”bean.properties\”);
Properties properties = new Properties();
try {
properties.load(is);
} catch (IOException e) {
throw new RuntimeException(e);
}

// 遍历配置文件的所有配置信息
Enumeration<Object> keys = properties.keys();
while (keys.hasMoreElements()){
String key = keys.nextElement().toString();
String value = properties.getProperty(key);
try {
// 创建对象，将对象放入集合
Object o = Class.forName(value).newInstance();
map.put(key,o);
} catch (Exception e) {
e.printStackTrace();
}
}

}

// 从容器中获取对象
public static Object getBean(String key){
return map.get(key);
}
}

创建Dao对象的调用者StudentService

public class StudentService {
public Student findStudentById(int id){
StudentDao studentDao = (StudentDao) Container.getBean(\”studentDao\”);
System.out.println(studentDao.hashCode());
return studentDao.findById(id);
}
}

测试StudentService

public class Test {
public static void main(String[] args) {
StudentService studentService = new StudentService();
System.out.println(studentService.findStudentById(1));
System.out.println(studentService.findStudentById(1));
}
}

StudentService从容器中每次拿到的都是同一个StudentDao对象，节约了资源。

如果想使用StudentDaoImpl2对象，只需要修改bean.properties的内容为

studentDao=com.itbaizhan.dao.StudentDaoImpl2

即可，无需修改Java源码。

创建Maven工程，引入依赖

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.11</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>

创建POJO类、Dao类和接口

public class Student {
private int id;
private String name;
private String address;
// 省略getter/setter/构造方法/tostring
}

public interface StudentDao {
// 根据id查询学生
Student findById(int id);
}

public class StudentDaoImpl implements StudentDao{
@Override
public Student findById(int id) {
// 模拟从数据库查找出学生
return new Student(1,\”百战程序员\”,\”北京\”);
}
}

编写xml配置文件，配置文件中配置需要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 id=\”studentDao\” class=\”com.itbaizhan.dao.StudentDaoImpl\”></bean>

</beans>

测试从Spring容器中获取对象。

public class TestContainer {
@Test
public void t1(){
// 创建Spring容器
ApplicationContext ac = new ClassPathXmlApplicationContext(\”bean.xml\”);
// 从容器获取对象
StudentDao studentDao1 = (StudentDao) ac.getBean(\”studentDao\”);
StudentDao studentDao2 = (StudentDao) ac.getBean(\”studentDao\”);
System.out.println(studentDao1.hashCode());
System.out.println(studentDao2.hashCode());
System.out.println(studentDao1.findById(1));
}
}

创建工厂类，工厂类提供创建对象的方法：

public class StudentDaoFactory {
public StudentDao getStudentDao(){
return new StudentDaoImpl(1);
}
}

在配置文件中配置创建bean的方式为工厂方式。

<!– id：工厂对象的id，class：工厂类 –>
<bean id=\”studentDaoFactory\” class=\”com.itbaizhan.dao.StudentDaoFactory\”></bean>
<!– id：bean对象的id，factory-bean：工厂对象的id，factory-method：工厂方法 –>
<bean id=\”studentDao\” factory-bean=\”studentDaoFactory\” factory-method=\”getStudentDao\”></bean>

测试

创建工厂类，工厂提供创建对象的静态方法。

public class StudentDaoFactory2 {
public static StudentDao getStudentDao2() {
return new StudentDaoImpl();
}
}

在配置文件中配置创建bean的方式为工厂静态方法。

<!– id:bean的id class:工厂全类名 factory-method:工厂静态方法 –>
<bean id=\”studentDao\” class=\”com.itbaizhan.dao.StudentDaoFactory2\” factory-method=\”getStudentDao2\”></bean>

测试

定义生命周期方法

public class StudentDaoImpl2 implements StudentDao{
// 创建时自动执行的方法
public void init(){
System.out.println(\”创建StudentDao！！！\”);
}

// 销毁时自动执行的方法
public void destory(){
System.out.println(\”销毁StudentDao！！！\”);
}
}

配置生命周期方法

<!– init-method:创建对象时执行的方法 destroy-method:销毁对象时执行的方法 –>
<bean id=\”studentDao\” class=\”com.itbaizhan.dao.StudentDaoImpl2\” scope=\”singleton\”
init-method=\”init\” destroy-method=\”destory\”></bean>

测试

@Test
public void t3(){
// 创建Spring容器
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext(\”bean1.xml\”);

// 销毁Spring容器，ClassPathXmlApplicationContext才有销毁容器的方法
ac.close();
}

配置文件

<
bean
name=
\”studentDao\”
class=
\”com.itbaizhan.dao.StudentDaoImpl2\”
></
bean
>

<
bean
id=
\”studentDao\”
class=
\”com.itbaizhan.dao.StudentDaoImpl2\”
></
bean
>

获取对象

StudentDao
studentDao
= (
StudentDao)
ac.
getBean(
\”studentDao\”);

配置文件