Spring框架及Bean详解

Spring框架及Bean详解

Spring框架是什么？

​ Spring是分层的JavaSE/EE full-stack 轻量级开源框架，以IoC（Inverse of Control 控制反转）和AOP（Aspect Oriented Programming 面向切面编程）为内核，使用基本的JavaBean来完成以前只可能由EJB完成的工作，取代了EJB的臃肿、低效的开发模式。

为什么使用Spring框架？

7大优点	解释或优点的意义
非侵入式设计的框架	使应用程序对框架依赖最小化
方便解耦、简化开发	对象的创建和依赖关系的维护交由Spring容器管理，降低组件之间的耦合性
支持AOP	允许安全、事务、日志等通用任务集中式处理，提高程序复用性
支持声明式事务处理	配置即可完成事务管理，无需手动编程
方便程序测试	支持Junit4
方便集成各种优秀框架	不排斥优秀的开源框架
降低Java EE API的使用难度	提供了难用ＡPI的封装，如JDBC

Spring体系结构

下面仅解析Core Container（核心容器)的部分模块,其他知识点自行找度娘吧！

模块名	解析
Beans	提供了BeanFactory，Spring将管理对象称为Bean（别误解为实体类）
Core核心模块	提供了Spring框架的基本组成部分，包括IoC和DI功能
Context上下文模块	建立在Core和Beans模块的基础之上，它是访问定义和配置的任何对象的媒介。

怎么使用Spring框架？

Spring框架的主要功能是通过其核心容器实现的，Spring容器会负责控制程序之间的关系，而不是由程序代码直接控制。Spring为我们提供了两种核心容器，分别为BeanFactory和ApplicationContext。

• BeanFactory
  其是基础类型的loC容器，提供了完整的loC服务支持。本质就是一个管理Bean的工厂，主要负责初始化各种Bean，并调用他们的生命周期。
  如何装配Bean？
  创建BeanFactory实例时，需要提供Spring所管理容器的详细配置信息，这些信息通常采用XML文件形式来管理，其加载配置信息的语法如下：

BeanFactory beanFactory =  new XmlBeanFactory(new FileSystemResource("F: /applicationContext.xml"))

此种加载方式不常用，了解即可，不再赘述。

• ApplicationContext
  ApplicationContext是BeanFactory的子接口，是另一种常用的Spring核心容器。它由org.springframework.context.ApplicationContext接口定义，不仅包含了BeanFactory的所有功能，还添加了对国际化、资源访问、事件传播等方面的支持。创建ApplicationContext接口实例，通常采用两种方法，具体如下：

1)通过ClassPathXmlApplicationContext创建

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation);

String configLocation：指定Spring配置文件的名称和位置。
ClassPathXmlApplicationContext会从类路径classPath中寻找指定的XML配置文件，找到并装载完成ApplicationContext的实例化工作。
2) 通过FileSystemXmlApplicationContext创建

 ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation);

• 在Java项目中，会通过ClassPathXmlApplicationContext类来实例化ApplicationContext容器。
• 重点来了：
  在Web项目中，ApplicationContext容器的实例化工作会交由Web服务器来完成。
  Web服务器实例化ApplicationContext容器时，通常会使用ContextLoaderListener来实现，此种方式只需要在web.xml中添加如下代码： 先指定Spring配置文件的位置，多个配置文件时，以逗号分隔。再指定以ContestLoaderListener方式启动Spring容器。

<context-param>
          <param-name>contextConfigLocation</param-name> 
               <param-value>
                          classpath:spring/applicationContext.xml
               </param-value>
       </context-param>
             <listener>
               <listener-class>
                         org.springframework.web.context.ContextLoaderListener
               </listener-class>
       </listener>

程序示例

1.创建接口UserDao，然后在接口中定义一个say()方法。

 public interface UserDao {
   	public void say();
        }

2.创建UserDao接口的实现类UserDaoImpl，该类需要实现接口中的say()方法，并在方法中编写一条输出语句。

 public class UserDaoImpl implements UserDao {
	public void say() {
                         System.out.println("userDao say hello World !");
 	}
       }

3.创建Spring的配置文件applicationContext.xml，并在配置文件中创建一个id为userDao的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"
                    xsi:schemaLocation="http://www.springframework.org/schema/beans 
                    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd"> 
             <bean id="userDao" class="com.itheima.ioc.UserDaoImpl" />
       </beans>

注：解析（beanid=“userDao” class=“com.itheima.ioc.UserDaoImpl” ）
Spring获取Bean的实例，根据容器中Bean的id或name来获取指定的Bean，获取之后需要进行强制类型转换。class属性是用于指定需要实例化Bean的类
4.创建测试类TestIoC，需要初始化Spring容器，并加载配置文件，然后通过Spring容器获取userDao实例（即Java对象），最后调用实例中的say()方法。

        import org.springframework.context.ApplicationContext;
        import  org.springframework.context.support.ClassPathXmlApplicationContext;
        public class TestIoC {
               public static void main(String[] args) { 
               //初始化Spring容器，加载配置文件
 	       ApplicationContext applicationContext = 
	              new ClassPathXmlApplicationContext("applicationContext.xml"); 
	              //通过容器获取UserDao实例
                      UserDao userDao = (UserDao) applicationContext.getBean("userDao");
                      //调用实例中的方法
 	      userDao.say();
              }
       }

思考：控制台已成功输出了UserDaoImpl类中的输出语句，但并没有new关键字创建UserDao接口的实现类对象，而是通过Spring容器来获取的实现类对象？
答案：其实这就是Spring loC容器的工作机制

Spring中的DI与loC详解

DI的全称是Dependency Injection，中文称之为依赖注入。它与控制反转（IoC）的含义相同，只不过这两个称呼是从两个角度描述的同一个概念。
依赖注入的实现方式：
1.使用setter方法实现依赖注入
程序示例：
创建接口UserService，在接口中编写一个say()方法

 public interface UserService {
                 public void say();
        }

创建UserService接口的实现类UserServiceImpl，在类中声明userDao属性，并添加属性的setter方法。

  public class UserServiceImpl implements UserService {
	private UserDao userDao; 
	public void setUserDao(UserDao userDao) {
	         this.userDao = userDao;
	} 
	public void say() { 
	         this.userDao.say();
	         System.out.println("userService say hello World !");
	}
         }

在配置文件applicationContext.xml中，创建一个id为userService的Bean，该Bean用于实例化UserServiceImpl类的信息，并将userDao的实例注入到userService中。

//添加id="userService"的实例，并将id为userDao的Bean实例注入到userService实例中
<bean id="userService" class="com.itheima.ioc.UserServiceImpl"> 
                 <property name="userDao" ref="userDao" />
        </bean>

在上边代码中property是bean元素的子元素，用于调用（id=“userService”）Bean实例中的setUserDao()方法完成赋值，从而实现依赖注入。
其name属性表示Bean实例（id=“userService”）中的相应属性名，ref属性用于指定Bean实例（id=“userService”）中的其属性值
name所指的userDao并不是指(id=“UserDao”)中的Bean。
那你可能会问了，把UseDao类导入进来，此类再声明一个对象，对象调用方法也很正常么。这样配置还有用么？
解释： 注意看 this.userDao.say();那么这个this指什么呢？如果不是配置还能当做UserServiceImplement类自己的属性使用了吗？能这样写吗？既然不能那就是A类依赖B类，聚合什么的了吧？之所以这样写 this.userDao.say();没有错误，就是Spring依赖注入的重要知识点了呀
创建测试类TestDI，来对程序进行测试

import org.springframework.context.ApplicationContext;
        import org.springframework.context.support.ClassPathXmlApplicationContext;
        public class TestDI {
	public static void main(String[] args) { 
	        ApplicationContext applicationContext = 
                        new ClassPathXmlApplicationContext("applicationContext.xml"); 
	        UserService userService = 
                                         (UserService) applicationContext.getBean("userService"); 
	        userService.say();
	}
        }

结果输出：

加一个小总结（学习的时候注意区分）

诉求	方法一	方法二	方法三
Bean实例化	构造器（最常用）	静态工厂	实例工厂
Bean装配	基于XML装配	接口或类中实现配置（注解）	隐式Bean的发现机制和自动装配原则（常用）
XML装配分为	设置注入	构造注入

|DI（依赖注入）|setter注入（常用）|构造注入|其他方式（c命名空间、p命名空间）

Spring中的Bean详解

Spring中的Bean

Spring中的Bean是什么？
如果把Spring看做一个大型工厂，则Spring容器中的Bean就是该工厂的产品。要想使用这个工厂生产和管理Bean，就需要在配置文件中配置他，告诉它需要哪些Bean，以及需要使用何种方式将这些Bean装配到一起。
Bean的本质就是Java中的类，而Spring中的Bean其实就是对实体类的引用，来生产Java类对象，从而实现生产和管理Bean 。

bean的常用属性及其元素

通过XML文件来注册并管理Bean之间的依赖关系
在配置文件中，通常一个普通的Bean只需要定义id（或name）和class 两个属性即可，定义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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd">
            <bean id="bean1" class="com.itheima.Bean1" />
            <bean name="bean2" class="com.itheima.Bean2" />
    </beans>

注：如果在Bean中未指定id和name，则Spring会将class值当作id使用。

Bean的实例化

实例化Bean有三种方式，分别为构造器实例化、静态工厂方式实例化和实例工厂方式实例化（其中最常用的是构造器实例化）。

• 构造器实例化
  指Spring容器通过Bean对应类中默认无参构造方法来实例化Bean
  程序：
  创建Bean1类：

public class Bean1{
}

创建配置文件beans1.xml

 <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-4.3.xsd">
           <bean id="bean1" class="com.itheima.instance.constructor.Bean1" />
    </beans>

创建测试类

public class InstanceTest1 {
       public static void main(String[] args) {
       //定义配置文件路径
     	String xmlPath = "com/itheima/instance/constructor/beans1.xml";
     	//ApplicationContext在加载配置文件时，对Bean实例化
               ApplicationContext applicationContext = 
			    new ClassPathXmlApplicationContext(xmlPath);
	Bean1 bean = (Bean1) applicationContext.getBean("bean1");
                System.out.println(bean);
      }
}

• 静态工厂方式实例化
  创建MyBean2Factory类，并创建静态方法来返回Bean2实例。(　如果一个Bean不能通过new直接实例化，而是通过工厂类的某个静态方法创建的，需要把的class属性配置为工厂类。)

 public class MyBean2Factory {	
         public static Bean2 createBean(){
              return new Bean2();
         }
   }

配置文件的bean元素为：

<bean id="bean2" class="com.itheima.instance.static_factory.MyBean2Factory" 
		   factory-method="createBean" />

创建测试类

   public class InstanceTest2 {
         public static void main(String[] args) {
	String xmlPath ="com/itheima/instance/static_factory/beans2.xml";
 	ApplicationContext applicationContext = 
 			         new ClassPathXmlApplicationContext(xmlPath);
 	System.out.println(applicationContext.getBean("bean2"));
         }
  }

• 实例工厂方式实例化
  (　如果一个Bean不能通过new直接实例化，而是通过工厂类的某个实例方法创建的，需要先配置工厂的标签，然后在需要创建的对象的bean标签的factory-bean属性配置为工厂类对象，factory-method属性配置为产生实例的方法。)
  不在赘述直接看代码哈。

 public class MyBean3Factory {
          public Bean3 createBean(){
                 return new Bean3();
          }
    }

<bean id = "myBean3Factory" class = "....MyBean3Factory"/>
//使用factory-bean 属性指向配置的实例工厂
//使用factory-method属性确定使用工厂中的哪个方法
<bean id ="bean3" factory-bean= "myBean3Fatory" factory-method = "creatBean">

 public class InstanceTest3 {
       public static void main(String[] args) {
	String xmlPath = "com/itheima/instance/factory/beans3.xml";
	ApplicationContext applicationContext = 
 			         new ClassPathXmlApplicationContext(xmlPath);
 	System.out.println(applicationContext.getBean("bean3"));
        }
 } 

Bean的7种作用域

singleton是Spring容器默认的作用域，当Bean的作用域为singleton时，Spring容器就只会存在一个共享的Bean实例。singleton作用域对于无会话状态的Bean（如Dao 组件、Service组件）来说，是最理想的选择。
在Spring配置文件中，可以使用元素的scope属性，将Bean的作用域定义成singleton。

<bean id="scope" class="com.itheima.scope.Scope" scope="singleton"/>

对需要保持会话状态的Bean（如Struts 2的Action类）应该使用prototype作用域。在使用prototype作用域时，Spring容器会为每个对该Bean的请求都创建一个新的实例。

<bean id="scope" class="com.itheima.scope.Scope" scope=" prototype "/>

Bean的装配方式

基于XML的装配、基于注解（Annotation）的装配和自动装配（其中最常用的是基于注解的装配）

具体的不在赘述，至少要知道创建Java类，提供有参、无参构造以及属性setter方法；

具体演示：






自动装配略，写的简单了，如果这里没您想要的，接着麻烦度娘吧！

IoC和DI的区别

IoC，控制反转，将传统的对象创建流程转变为交由框架进行创建和管理。在Spring中，对象的创建交给Spring进行配置。它包括依赖注入。
　　DI，依赖注入，向类的属性设置值。
　　IoC与DI的关系：依赖注入不能单独存在，需要在IoC基础之上完成操作。

Spring基础核心知识清单

什么是spring

spring的特点

Spring包括哪些内容

使用Spring有什么好处

spring中的核心类有那些，各有什么作用

spring常用的类和接口有哪些

spring事务的原理

什么是IOC，什么又是DI，他们有什么区别

Bean注入属性的几种方式

什么是aop，aop的作用是什么

AOP里面重要的几个名词概念解释

Spring框架中Bean的生命周期和作用域

Bean的初始化方式有哪些

Bean的调用方式有哪些

Bean的销毁方式有哪些

Spring的事务管理

Spring里面如何配置数据库驱动

Spring里面applicationContext.xml文件能不能改成其他文件名

如何在web应用里面配置spring

spring中的BeanFactory与ApplicationContext的作用有哪些

BeanFactory 接口 和 ApplicationContext 接口区别

如何在web环境中配置applicationContext.xml文件

如何在spring中实现国际化

Spring如何处理线程并发问题

Spring 中BeanFactory与ApplicationContext的差别

服务挂了，如何解决

常见的设计模式和应用

聚合器微服务设计模式

代理微服务设计模式

链式微服务设计模式

分支微服务设计模式

数据共享微服务设计模式

异步消息传递微服务设计模式

微服务架构对于部署的要求

微服务部署的粒度

MS部署的解决方案

微服务的划分

微服务分布式一致性

微服务数据隔离问题

COMB支持哪些常见的协议

如何集成Spring Boot和ActiveMQ？

springboot常用的starter有哪些

springboot读取配置文件的方式

springboot集成mybatis的过程

如何重新加载Spring Boot上的更改，而无需重新启动服务器？

如何在Spring Boot中禁用Actuator端点安全性？

如何在 Spring Boot 启动的时候运行一些特定的代码？

Spring Boot 如何定义多套不同环境配置？

保护 Spring Boot 应用有哪些方法？.

Spring AOP

AOP

推荐博客
推荐博客
如需转载，请注明出处：https://blog.csdn.net/weixin_42618873/article/details/99694557