• spring入门

    目录

    Spring的基本概念

    🚩spring是什么？

    🚩spring项目的出发点：

    🚩spring的控制反转(依赖注入)

    AOP是什么 ？ 

    示例：

    🏳‍🌈创建web工程

    🏳‍🌈配置pom文件

    🏳‍🌈创建spring的配置文件

    🏳‍🌈示例

    ①示例一(普通)

    ②示例二(sbstract和parent的使用) 

    ③示例三(有参构造创建javaBean)

    ④实例四(init-method的使用)

    ⑤示例五(复杂属性-引入属性的使用ref)

    ⑥示例六(集合、数组的使用) 

    ⑦多配置文件的处理

    Spring的基本概念

    🚩spring是什么？

    spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

    🚩spring项目的出发点：

    • 目的：提供一种贯穿始终的解决方面，将各种专用框架整合成一个连贯的整体框架，简化企业级应用的开发（有点像粘合剂）
    • 鼓励最佳实践： 例如spring将“针对接口编程”的成本降到了最小
    • 非侵入性： 应用对象尽量避免依赖框架，IoC和AOP是避免依赖的关键技术
    • 统一配置： 好的框架应该让应用配置灵活且统一
    • 易于测试： 使单元测试尽可能简单
    • 可扩展：

    简单来说，spring就是一个轻量级的控制(IOC)和面向切面编程(AOP)的容器框架。

    🚩spring的控制反转(依赖注入)

    控制反转IOC(inversion of control)，控制反转其实就是控制权的反转，我们都知道传统的，由代码直接操控的，那么反转了之后就是将控制权直接给到了外部的容器。这就是反转的概念 。控制反转又被称为依赖注入DI(Dependency Injection) ，意思就是由容器动态的将某种关系注入到组件中去。 

    AOP是什么 ？ 

    • 连接点(Joinpoint)：程序执行过程中明确的点，如方法的调用，或者异常的抛出.
    • 目标(Target)：被通知(被代理)的对象
    • 通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)
    • 代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知),请注意：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的
    • 切入点(Pointcut)：多个连接点的集合，定义了通知应该应用到那些连接点。(也将Pointcut理解成一个条件 ，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)
    • 适配器(Advisor)：适配器=通知(Advice)+切入点(Pointcut) 

    示例：

    🏳‍🌈创建web工程

    这里我们直接创建一个web项目，并转换为web3.1，具体步骤见maven的安装和使用_一麟yl的博客-CSDN博客

    🏳‍🌈配置pom文件

    下面是我们需要的依赖配置。

    注意：个人建议需要什么用到什么模块就使用什么模块的依赖。

    1. <properties>
    2. 		<hibernate.version>5.2.12.Finalhibernate.version>
    3. 		<mysql.driver.version>5.1.44mysql.driver.version>
    4. 		<spring.version>5.2.6.RELEASEspring.version>
    5. 		<struts2.version>2.5.13struts2.version>
    6. 		<slf4j.version>1.7.7slf4j.version>
    7. 		<log4j.version>2.9.1log4j.version>
    8. 		<disruptor.version>3.2.0disruptor.version>
    9. 		<junit.version>4.12junit.version>
    10. 		<servlet.version>4.0.1servlet.version>
    11. 		<jstl.version>1.2jstl.version>
    12. 		<standard.version>1.1.2standard.version>
    13. 		<tomcat-jsp-api.version>8.5.20tomcat-jsp-api.version>
    14. 	properties>
    15.  
    16. 	<dependencies>
    17.  
    18. 		<dependency>
    19. 			<groupId>junitgroupId>
    20. 			<artifactId>junitartifactId>
    21. 			<version>4.12version>
    22. 			<scope>testscope>
    23. 		dependency>
    24.  
    25. 		
    26. 		<dependency>
    27. 			<groupId>org.springframeworkgroupId>
    28. 			<artifactId>spring-coreartifactId>
    29. 			<version>${spring.version}version>
    30. 		dependency>
    31. 		<dependency>
    32. 			<groupId>org.springframeworkgroupId>
    33. 			<artifactId>spring-contextartifactId>
    34. 			<version>${spring.version}version>
    35. 		dependency>
    36. 		<dependency>
    37. 			<groupId>org.springframeworkgroupId>
    38. 			<artifactId>spring-ormartifactId>
    39. 			<version>${spring.version}version>
    40. 		dependency>
    41. 		<dependency>
    42. 			<groupId>org.springframeworkgroupId>
    43. 			<artifactId>spring-webartifactId>
    44. 			<version>${spring.version}version>
    45. 		dependency>
    46. 		<dependency>
    47. 			<groupId>org.springframeworkgroupId>
    48. 			<artifactId>spring-testartifactId>
    49. 			<version>${spring.version}version>
    50. 		dependency>
    51. 		<dependency>
    52. 			<groupId>org.springframeworkgroupId>
    53. 			<artifactId>spring-aopartifactId>
    54. 			<version>${spring.version}version>
    55. 		dependency>
    56. 		<dependency>
    57. 			<groupId>org.springframeworkgroupId>
    58. 			<artifactId>spring-aspectsartifactId>
    59. 			<version>${spring.version}version>
    60. 		dependency>
    61. 		<dependency>
    62. 			<groupId>org.springframeworkgroupId>
    63. 			<artifactId>spring-beansartifactId>
    64. 			<version>${spring.version}version>
    65. 		dependency>
    66. 		<dependency>
    67. 			<groupId>org.springframeworkgroupId>
    68. 			<artifactId>spring-jdbcartifactId>
    69. 			<version>${spring.version}version>
    70. 		dependency>
    71.  
    72. 		
    73. 		<dependency>
    74. 			<groupId>mysqlgroupId>
    75. 			<artifactId>mysql-connector-javaartifactId>
    76. 			<version>${mysql.driver.version}version>
    77. 		dependency>
    78. 	
    79. 		
    80. 		
    81. 		<dependency>
    82. 			<groupId>org.slf4jgroupId>
    83. 			<artifactId>slf4j-apiartifactId>
    84. 			<version>${slf4j.version}version>
    85. 		dependency>
    86. 		<dependency>
    87. 			<groupId>org.slf4jgroupId>
    88. 			<artifactId>jcl-over-slf4jartifactId>
    89. 			<version>${slf4j.version}version>
    90. 			<scope>runtimescope>
    91. 		dependency>
    92.  
    93. 		
    94. 		<dependency>
    95. 			<groupId>org.apache.logging.log4jgroupId>
    96. 			<artifactId>log4j-slf4j-implartifactId>
    97. 			<version>${log4j.version}version>
    98. 			<exclusions>
    99. 				<exclusion>
    100. 					<artifactId>slf4j-apiartifactId>
    101. 					<groupId>org.slf4jgroupId>
    102. 				exclusion>
    103. 			exclusions>
    104. 		dependency>
    105.  
    106. 		
    107. 		<dependency>
    108. 			<groupId>org.apache.logging.log4jgroupId>
    109. 			<artifactId>log4j-apiartifactId>
    110. 			<version>${log4j.version}version>
    111. 		dependency>
    112. 		<dependency>
    113. 			<groupId>org.apache.logging.log4jgroupId>
    114. 			<artifactId>log4j-coreartifactId>
    115. 			<version>${log4j.version}version>
    116. 		dependency>
    117.  
    118. 		
    119. 		<dependency>
    120. 			<groupId>org.apache.logging.log4jgroupId>
    121. 			<artifactId>log4j-webartifactId>
    122. 			<version>${log4j.version}version>
    123. 			<scope>runtimescope>
    124. 		dependency>
    125. 		
    126. 		<dependency>
    127. 			<groupId>com.lmaxgroupId>
    128. 			<artifactId>disruptorartifactId>
    129. 			<version>${disruptor.version}version>
    130. 		dependency>
    131.  
    132. 		
    133. 		<dependency>
    134. 			<groupId>junitgroupId>
    135. 			<artifactId>junitartifactId>
    136. 			<version>${junit.version}version>
    137. 			<scope>testscope>
    138. 		dependency>
    139. 		<dependency>
    140. 			<groupId>javax.servletgroupId>
    141. 			<artifactId>javax.servlet-apiartifactId>
    142. 			<version>${servlet.version}version>
    143. 			<scope>providedscope>
    144. 		dependency>
    145.  
    146. 		
    147. 		<dependency>
    148. 			<groupId>javax.servlet.jsp.jstlgroupId>
    149. 			<artifactId>jstlartifactId>
    150. 			<version>${jstl.version}version>
    151. 		dependency>
    152. 		<dependency>
    153. 			<groupId>taglibsgroupId>
    154. 			<artifactId>standardartifactId>
    155. 			<version>${standard.version}version>
    156. 		dependency>
    157.  
    158. 		
    159. 		<dependency>
    160. 			<groupId>org.apache.tomcatgroupId>
    161. 			<artifactId>tomcat-jsp-apiartifactId>
    162. 			<version>${tomcat-jsp-api.version}version>
    163. 			<scope>providedscope>
    164. 		dependency>
    165.  
    166. 	dependencies>

    注： 该依赖配置不仅包含了spring，同时也包含了hibernate，struts，mysql驱动等。

    🏳‍🌈创建spring的配置文件

    spring.xml

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    4. 	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    5. 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    6. 		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
    7. 		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
    8. 		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
    9.  
    10.  
    11. 	
    12. beans>

    进行到这里我们的容器就算搭建好了，我们来两个实例。

    🏳‍🌈示例

    ①示例一(普通)

    🟠这里我们创建一个学生实体类(Student.java)

    1. package com.ljq.spring01.model;
    2.  
    3. /**
    4.  * 学生实体
    5.  * @author 一麟
    6.  *
    7.  */
    8. public class Student  {
    9. 	
    10. 	private String name;
    11.  
    12. 	public String getName() {
    13. 		return name;
    14. 	}
    15.  
    16. 	public void setName(String name) {
    17. 		this.name = name;
    18. 	}
    19.  
    20. 	@Override
    21. 	public String toString() {
    22. 		return "Student [name=" + name + "]";
    23. 	}
    24. 	
    25. }

    🟢并在spring.xml文件中配置好

    1. <bean id="demo" class="com.ljq.spring01.model.Student">
    2. 		<property name="name">
    3. 			<value>一麟value>
    4. 		property>
    5. 	bean>

    配置文件说明：

    ID:在容器中确保了bean的唯一(不能以/开头)

    class:bean的权限类名

    name：在容器中标记bean的名字(唯一，不能以/开头，能够存在多个值，用逗号隔开)

    scope:(singleton|prototype)默认是singleton
    singleton: 单例模式, 在每个Spring IoC容器中一个bean定义对应一个对象实例
    prototype： 原型模式/多例模式, 一个bean定义对应多个对象实例

    parent：指定一个父bean(必须要有继承关系才行)

    abstract: 将一个bean定义成抽象bean(抽象bean是不能实例化的),抽象类一定要定义成抽象bean,非抽象类也可以定义成抽象bean

    🟤main方法测试

    1. package com.ljq.spring01.test;
    2.  
    3. import org.springframework.context.support.ClassPathXmlApplicationContext;
    4.  
    5. import com.ljq.spring01.model.Student;
    6.  
    7. /**
    8.  * 测试
    9.  * 
    10.  * @author 一麟
    11.  *
    12.  */
    13. public class Test {
    14.  
    15. 	public static void main(String[] args) {
    16. 		// 获取spring.xml文件的上下文
    17. 		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
    18. 		// 用上下文获得ID为student的bean
    19. 		Student stu = (Student) ctx.getBean("student");
    20. 		System.out.println(stu);
    21. 	}
    22.  
    23. }

    运行结果：

    ②示例二(sbstract和parent的使用) 

    这里我们给student实体类安排一个父类(person):

    1. package com.ljq.spring01.model;
    2.  
    3. /**
    4.  * 人物实体类
    5.  * 
    6.  * @author 一麟
    7.  *
    8.  */
    9. public abstract class Person {
    10.  
    11. 	private Integer age;
    12.  
    13. 	public Integer getAge() {
    14. 		return age;
    15. 	}
    16.  
    17. 	public void setAge(Integer age) {
    18. 		this.age = age;
    19. 	}
    20.  
    21. }

    并让student实体类继承这个类：

    1. package com.ljq.spring01.model;
    2.  
    3. /**
    4.  * 学生实体
    5.  * 
    6.  * @author 一麟
    7.  *
    8.  */
    9. public class Student extends Person {
    10.  
    11. 	private String name;
    12.  
    13. 	public String getName() {
    14. 		return name;
    15. 	}
    16.  
    17. 	public void setName(String name) {
    18. 		this.name = name;
    19. 	}
    20.  
    21. 	@Override
    22. 	public String toString() {
    23. 		return "Student [name=" + name + "]";
    24. 	}
    25.  
    26. }

    然后就是配合spring.xml文件：

    2. 	<bean id="student" class="com.ljq.spring01.model.Student" parent="person">
    3. 		<property name="name">
    4. 			<value>一麟value>
    5. 		property>
    6. 	bean>
    7.  
    8. 	
    9. 	<bean id="person" class="com.ljq.spring01.model.Person" abstract="true">
    10. 		<property name="age">
    11. 			<value>18value>
    12. 		property>
    13. 	bean>

    继续运行我们上面的test类的main方法：

    1. public static void main(String[] args) {
    2. 		// 获取spring.xml文件的上下文
    3. 		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
    4. 		// 用上下文获得ID为student的bean
    5. 		Student stu = (Student) ctx.getBean("student");
    6. 		System.out.println("学生名字:"+stu.getName());
    7. 		System.out.println("学生年龄:"+stu.getAge());
    8. 	}

    运行结果：

    ③示例三(有参构造创建javaBean)

    注意：这种方式我们一定在实体类中写好有参构造

    这里我们在student类中加入有参构造： 

    1. public Student(String name) {
    2. 		super();
    3. 		this.name = name;
    4. 	}

    这种方式跟第二种方式是差不多的，只需要将bean中的property改为constructor即可，配置文件如下：

    1. <bean id="student" class="com.ljq.spring01.model.Student" parent="person">
    2. 		
    3. 		<constructor-arg index="0">
    4. 			<value>一麟value>
    5. 		constructor-arg>
    6. 	bean>

    这种构造方法是根据属性的下标来植入值的，我们也可以直接设置属性名字如：

    1. <bean id="student" class="com.ljq.spring01.model.Student" parent="person">
    2. 		
    3. 		
    4. 		 <constructor-arg name="name">
    5. 				<value>一麟value>
    6. 		 constructor-arg>
    7. 	bean>

    运行之前的main方法，运行结果如下：

    ④实例四(init-method的使用)

    这种方式其实也很简单，就是在实体类中写一个初始化的方法，然后在容器中的bean直接配置即可。

    首先，我们在student类中加入init方法：

    1.     /**
    2. 	 * 初始化方法,表示正常启动
    3. 	 */
    4. 	public void init() {
    5. 		System.out.println("我是"+this.name+"大帅哥");
    6. 	}

    然后配置spring.xml文件：

    1. <bean id="student" class="com.ljq.spring01.model.Student" parent="person" init-method="init">
    2. 		
    3. 		
    4. 		 <constructor-arg name="name">
    5. 				<value>一麟value>
    6. 		 constructor-arg>
    7. 	bean>

    最后还是使用之前的main方法测试，结果如下：

    ⑤示例五(复杂属性-引入属性的使用ref)

    这里我们先创建一个地址实体类方便测试address.java:

    1. package com.ljq.spring01.model;
    2.  
    3. /**
    4.  * 地址实体类
    5.  * 
    6.  * @author 一麟
    7.  *
    8.  */
    9. public class Address {
    10.  
    11. 	private String city;// 城市
    12.  
    13. 	private String street;// 街道
    14.  
    15. 	public String getCity() {
    16. 		return city;
    17. 	}
    18.  
    19. 	public void setCity(String city) {
    20. 		this.city = city;
    21. 	}
    22.  
    23. 	public String getStreet() {
    24. 		return street;
    25. 	}
    26.  
    27. 	public void setStreet(String street) {
    28. 		this.street = street;
    29. 	}
    30.  
    31. 	@Override
    32. 	public String toString() {
    33. 		return "Address [city=" + city + ", street=" + street + "]";
    34. 	}
    35.  
    36. }

    并在student中加入address属性： 

    1.     private Address address;//地址
    2.  
    3. 	public Address getAddress() {
    4. 		return address;
    5. 	}
    6.  
    7. 	public void setAddress(Address address) {
    8. 		this.address = address;
    9. 	}

    spring.xml配置：

    2. 	<bean id="student" class="com.ljq.spring01.model.Student"
    3. 		parent="person" init-method="init">
    4. 		<property name="name">
    5. 			<value>一麟value>
    6. 		property>
    7. 		
    8. 		
    9. 		<property name="address" ref="address" />
    10. 	bean>
    11.  
    12. 	
    13. 	<bean id="person" class="com.ljq.spring01.model.Person"
    14. 		abstract="true">
    15. 		<property name="age">
    16. 			<value>18value>
    17. 		property>
    18. 	bean>
    19.  
    20. 	<bean id="address" class="com.ljq.spring01.model.Address">
    21. 		<property name="city">
    22. 			<value>长沙value>
    23. 		property>
    24. 		<property name="street">
    25. 			<value>天顶街道value>
    26. 		property>
    27. 	bean>

    main方法：

    1. public static void main(String[] args) {
    2. 		// 获取spring.xml文件的上下文
    3. 		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
    4. 		// 用上下文获得ID为student的bean
    5. 		Student stu = (Student) ctx.getBean("student");
    6. 		System.out.println("学生名字:" + stu.getName());
    7. 		System.out.println("学生年龄:" + stu.getAge());
    8. 		System.out.println("学生地址:" + stu.getAddress());
    9. 	}

    运行结果：

    ⑥示例六(集合、数组的使用) 

    不仅如此，spring容器还能够注入集合、数组。

    直接在student类中声明属性：

    1. private int[] arr;
    2. 	private List list;
    3. 	private Map map;
    4. 	private Properties prop;
    5. 	
    6. 	public Properties getProp() {
    7. 		return prop;
    8. 	}
    9.  
    10. 	public void setProp(Properties prop) {
    11. 		this.prop = prop;
    12. 	}
    13.  
    14. 	public int[] getArr() {
    15. 		return arr;
    16. 	}
    17.  
    18. 	public void setArr(int[] arr) {
    19. 		this.arr = arr;
    20. 	}
    21.  
    22. 	public List getList() {
    23. 		return list;
    24. 	}
    25.  
    26. 	public void setList(List list) {
    27. 		this.list = list;
    28. 	}
    29.  
    30. 	public Map getMap() {
    31. 		return map;
    32. 	}
    33.  
    34. 	public void setMap(Map map) {
    35. 		this.map = map;
    36. 	}

    修spring.xml配置文件：

    1. <bean id="student" class="com.ljq.spring01.model.Student"
    2. 		parent="person">
    3. 		
    4. 		
    5. 		
    6. 		
    7. 		
    8. 		<property name="list">
    9. 			<list>
    10. 				<value>湖南value>
    11. 				<value>湖北value>
    12. 				<value>意大利value>
    13. 			list>
    14. 		property>
    15. 		<property name="arr">
    16. 			<array>
    17. 				<value>1value>
    18. 				<value>2value>
    19. 				<value>3value>
    20. 			array>
    21. 		property>
    22. 		<property name="map">
    23. 			<map>
    24. 				<entry key="A" value="a" />
    25. 				<entry key="B" value="b" />
    26. 				<entry key="C" value="c" />
    27. 			map>
    28. 		property>
    29. 		<property name="prop">
    30. 			<props>
    31. 				<prop key="中国">Chainprop>
    32. 				<prop key="意大利">Italyprop>
    33. 				<prop key="美国">USprop>
    34. 			props>
    35. 		property>
    36. 	bean>

    main方法:

    1. public static void main(String[] args) {
    2. 		// 获取spring.xml文件的上下文
    3. 		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
    4. 		// 用上下文获得ID为student的bean
    5. 		Student stu = (Student) ctx.getBean("student");
    6. //		System.out.println("学生名字:" + stu.getName());
    7. //		System.out.println("学生年龄:" + stu.getAge());
    8. //		System.out.println("学生地址:" + stu.getAddress());
    9. 		System.out.println(Arrays.toString(stu.getArr()));
    10. 		System.out.println(stu.getList());
    11. 		System.out.println(stu.getMap());
    12. 		System.out.println(stu.getProp());
    13. 	}

    运行结果：

    ⑦多配置文件的处理

    当我们的工程存在多个模块需要配置多个配置文件的时候，一个一个获取上下文实属是不方便。

    这个时候我们可以将各个模块全部集成到一个配置文件里面。

    首先，我们将之前的spring.xml文件改为spring-a.xml假设这个文件负责a模块，然后重新创建一个新的spring.xml文件意为总配置文件：

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4. 	xmlns:aop="http://www.springframework.org/schema/aop"
    5. 	xmlns:context="http://www.springframework.org/schema/context"
    6. 	xmlns:tx="http://www.springframework.org/schema/tx"
    7. 	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    8. 		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
    9. 		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
    10. 		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
    11.  
    12. 	
    13. 	<import resource="spring-a.xml" />
    14.  
    15. beans>

    我们每次新增一个模块配置文件的时候只需要将其配置在总配置文件中即可，这个时候就能够解决多模块配置文件的问题了。

    🏳‍🌈简化bean的获取

    在我们之前的代码里面我们是这样获取bean对象的：

    1.         ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
    2. 		
    3. 		Student stu = (Student) ctx.getBean("student");

    这样写是存在问题的而且也不是方便，每次需要配置文件上下文的时候都需要new 一个

    ClassPathXmlApplicationContext，使得我们的工程的性能损耗，这样会导致什么问题呢？

    有没有想过如果我们的线程配合也在这个配置文件中，那么这个线程就会被启动两次，一次是web容器初始化启动的时候，另一次就是这个地方，被new的时候会被启动一次，就相当于被重新初始化了，这就是明显的冗余。

    那我们要这么解决这个问题呢？

    这个时候我们就选择不直接new ClassPathXmlApplicationContext，而是新建一个工具类实现ApplicationContextAware接口，实现之后就大大方便了我们获取ApplicationContext中的所有Bean，接下来我们来看看这个接口具体是使用。

    ApplicationContextAware的使用：

    1. package com.ljq.spring01.util;
    2.  
    3. import org.springframework.beans.BeansException;
    4. import org.springframework.context.ApplicationContext;
    5. import org.springframework.context.ApplicationContextAware;
    6. import org.springframework.stereotype.Component;
    7.  
    8. /**
    9.  * 简化获取bean
    10.  * 
    11.  * @author 一麟
    12.  *
    13.  */
    14. @Component
    15. public class SpringBeanUtil implements ApplicationContextAware {
    16.  
    17. 	private static ApplicationContext applicationContext;
    18.  
    19. 	/**
    20. 	 * spring通过注入的方式自动调用该方法将上下文设置好
    21. 	 */
    22. 	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    23. 		this.applicationContext = applicationContext;
    24. 	}
    25.  
    26. 	/**
    27. 	 * 根据bean的ID获取bean
    28. 	 * 
    29. 	 * @param 
    30. 	 * @param id
    31. 	 * @return
    32. 	 */
    33. 	public static  T getBean(String id) {
    34. 		Object object = null;
    35. 		object = applicationContext.getBean(id);
    36. 		return (T) object;
    37. 	}
    38.  
    39. }

    在这个类中我们通过实现ApplicationContextAware这个感知接口实现重写setApplicationContext方法，这个方法会被spring自动注入上下文，只需要在配置文件中加入

    2. 	<bean id="springBeanUtil"
    3. 		class="com.ljq.spring01.util.SpringBeanUtil">bean>

    或者在工具类中也需要加入注册注解：

    @Component

    这样我们的工具类就搞定了。

    下面是关于工具类的调用：main方法测试 ：

    1.         new ClassPathXmlApplicationContext("spring.xml");
    2.     	Student stu = (Student) SpringBeanUtil.getBean("student");
    3. 		System.out.println(Arrays.toString(stu.getArr()));
    4. 		System.out.println(stu.getList());
    5. 		System.out.println(stu.getMap());
    6. 		System.out.println(stu.getProp());

  • 相关阅读:
    Java并发-synchronized使用方法
    专业级游戏测试书上架：精通游戏测试（第3版）
    [附源码]java毕业设计农村电商平台
    C++特殊类设计
    4万字【Python高级编程】保姆式教学，进阶感觉到吃力？学完这些就轻松了
    网络编程基础
    高光谱遥感学习入门丨高光谱数据处理基础、Python和Matlab高光谱遥感数据处理
    手把手教你使用LabVIEW实现Mask R-CNN图像实例分割
    进程状态和Linux的进程状态
    HTuple HObject使用记录
  • 原文地址：https://blog.csdn.net/m0_67376124/article/details/126442985