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

孟村县网站建设价格百度指数人群画像怎么看

wzjs 2025/7/22 0:04:12
孟村县网站建设价格,百度指数人群画像怎么看,上海做网站找哪家好,做一个学校网站一、技术体系结构 1.总体技术体系 单体架构 一个项目，一个工程，导出为一个war包，在一个Tomcat上运行。也叫all in one。 单一架构，项目主要应用技术框架为：Spring , SpringMVC , Mybatis 分布式架构 一个项目&#xf…

一、技术体系结构

1.总体技术体系

单体架构

一个项目，一个工程，导出为一个war包，在一个Tomcat上运行。也叫all in one。

单一架构，项目主要应用技术框架为：Spring , SpringMVC , Mybatis

分布式架构

一个项目（对应 IDEA 中的一个 project），拆分成很多个模块，每个模块是一个 IDEA 中的一个 module。每一个工程都是运行在自己的 Tomcat 上。模块之间可以互相调用。每一个模块内部可以看成是一个单一架构的应用。

 分布式架构，项目主要应用技术框架：SpringBoot (SSM), SpringCloud , 中间件等

2.框架的概念和理解

框架( Framework )是一个集成了基本结构、规范、设计模式、编程语言和程序库等基础组件的软件系统，它可以用来构建更高级别的应用程序。框架的设计和实现旨在解决特定领域中的常见问题，帮助开发人员更高效、更稳定地实现软件开发目标。 

站在文件结构的角度理解框架，可以将框架总结：框架 = jar包+配置文件

就如铲子和挖掘机，普通的jar包工具类就像铲子一样，简单拿起来就用但是效率低。框架就好比挖掘机，虽然要学习开它比较麻烦，但是效率高。

jar包里面的方法是固定的，而框架可以通过配置文件实现定制化开发。就像是我们平常连接数据库使用的dbUtils工具类，就是单纯连接操作数据库。而log4j这个框架可以通过配置文件，调节日志输出的位置和格式。

 二、SpringFramework介绍

1.Spring和SpringFramework区分

广义上的 Spring ：Spring技术栈（全家桶）

广义上的 Spring 泛指以 Spring Framework 为基础的 Spring 技术栈。

经过十多年的发展，Spring 已经不再是一个单纯的应用框架，而是逐渐发展成为一个由多个不同子项目（模块）组成的成熟技术，例如 Spring Framework、Spring MVC、SpringBoot、Spring Cloud、Spring Data、Spring Security 等，其中 Spring Framework 是其他子项目的基础。

这些子项目涵盖了从企业级应用开发到云计算等各方面的内容，能够帮助开发人员解决软件发展过程中不断产生的各种实际问题，给开发人员带来了更好的开发体验。

狭义的 Spring：Spring Framework（基础框架）

狭义的 Spring 特指 Spring Framework，通常我们将它称为 Spring 框架。

Spring Framework（Spring框架）是一个开源的应用程序框架，由SpringSource公司开发，最初是为了解决企业级开发中各种常见问题而创建的。它提供了很多功能，例如：依赖注入（Dependency Injection）、面向切面编程（AOP）、声明式事务管理（TX）等。其主要目标是使企业级应用程序的开发变得更加简单和快速，并且Spring框架被广泛应用于Java企业开发领域。

Spring全家桶的其他框架都是以SpringFramework框架为基础！

对比理解：

QQ 和 腾讯

腾讯 = Spring

QQ = SpringFramework

2.SpringFramework主要功能模块 

SpringFramework框架结构图：

功能模块功能介绍
Core Container核心容器，在 Spring 环境下使用任何功能都必须基于 IOC 容器。
AOP&Aspects面向切面编程
TX声明式事务管理。
Spring MVC提供了面向Web应用程序的集成功能。

 3.SpringFramework主要优势

1. 丰富的生态系统：Spring 生态系统非常丰富，支持许多模块和库，如 Spring Boot、Spring Security、Spring Cloud 等等，可以帮助开发人员快速构建高可靠性的企业应用程序。
2. 模块化的设计：框架组件之间的松散耦合和模块化设计使得 Spring Framework 具有良好的可重用性、可扩展性和可维护性。开发人员可以轻松地选择自己需要的模块，根据自己的需求进行开发。
3. 简化 Java 开发：Spring Framework 简化了 Java 开发，提供了各种工具和 API，可以降低开发复杂度和学习成本。同时，Spring Framework 支持各种应用场景，包括 Web 应用程序、RESTful API、消息传递、批处理等等。
4. 不断创新和发展：Spring Framework 开发团队一直在不断创新和发展，保持与最新技术的接轨，为开发人员提供更加先进和优秀的工具和框架。

三、SpringIoC容器和核心概念

1.组件和组件管理的概念

放在SpringIoC容器里面的就是组件，组件就是各种Servlet、Service、BookDao类等，只要在其他层需要调用别的层的对象就是组件。就是可以复用的java对象。组件就是对象，对象不一定是组件。

而组件管理就是我们在一层中调用另外一层的类的组件，不需要我们直接去new一个组件对象，直接交给IoC容器管理创建。

2.使用SpringIoC优势

1. 降低了组件之间的耦合性：Spring IoC容器通过依赖注入机制，将组件之间的依赖关系削弱，减少了程序组件之间的耦合性，使得组件更加松散地耦合。
2. 提高了代码的可重用性和可维护性：将组件的实例化过程、依赖关系的管理等功能交给Spring IoC容器处理，使得组件代码更加模块化、可重用、更易于维护。
3. 方便了配置和管理：Spring IoC容器通过XML文件或者注解，轻松的对组件进行配置和管理，使得组件的切换、替换等操作更加的方便和快捷。
4. 交给Spring管理的对象（组件），方可享受Spring框架的其他功能（AOP,声明事务管理）等

3.SpringIoC的理解和实现

3.1普通容器和复杂容器

普通容器只能用来存储，没有更多功能。

程序中的普通容器

- 数组
- 集合：List
- 集合：Set

复杂容器除了存储还实现许多的管理功能

  程序中的复杂容器

  Servlet 容器能够管理 Servlet(init,service,destroy)、Filter、Listener 这样的组件的一生，所以它是一个复杂容器。

名称时机次数
创建对象默认情况：接收到第一次请求 修改启动顺序后：Web应用启动过程中一次
初始化操作创建对象之后一次
处理请求接收到请求多次
销毁操作Web应用卸载之前一次


我们即将要学习的 SpringIoC 容器也是一个复杂容器。它们不仅要负责创建组件的对象、存储组件的对象，还要负责调用组件的方法让它们工作，最终在特定情况下销毁组件。

总结：Spring管理组件的容器，就是一个复杂容器，不仅存储组件，也可以管理组件之间依赖关系，并且创建和销毁组件等！

3.2SpringIoC介绍

Spring IoC 容器，负责实例化、配置和组装 bean（组件）。容器通过读取配置元数据来获取有关要实例化、配置和组装组件的指令。配置元数据以 XML、Java 注解或 Java 代码形式表现。它允许表达组成应用程序的组件以及这些组件之间丰富的相互依赖关系。 

3.3SpringIoC容器具体接口和实现类

SpringIoc容器接口： 

`BeanFactory` 接口提供了一种高级配置机制，能够管理任何类型的对象，它是SpringIoC容器标准化超接口！

`ApplicationContext` 是 `BeanFactory` 的子接口。它扩展了以下功能：

- 更容易与 Spring 的 AOP 功能集成
- 消息资源处理（用于国际化）
- 特定于应用程序给予此接口实现，例如Web 应用程序的 `WebApplicationContext`

简而言之， `BeanFactory` 提供了配置框架和基本功能，而 `ApplicationContext` 添加了更多特定于企业的功能。 `ApplicationContext` 是 `BeanFactory` 的完整超集！

ApplicationContext容器实现类：

类型名简介
ClassPathXmlApplicationContext通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
FileSystemXmlApplicationContext通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象
AnnotationConfigApplicationContext通过读取Java配置类创建 IOC 容器对象
WebApplicationContext专门为 Web 应用准备，基于 Web 环境创建 IOC 容器对象，并将对象引入存入 ServletContext 域中。

3.4SpringIoC容器管理配置方式

Spring IoC 容器使用多种形式的配置元数据。此配置元数据表示您作为应用程序开发人员如何告诉 Spring 容器实例化、配置和组装应用程序中的对象。 

Spring框架提供了多种配置方式：XML配置方式、注解方式和Java配置类方式

1. XML配置方式：是Spring框架最早的配置方式之一，通过在XML文件中定义Bean及其依赖关系、Bean的作用域等信息，让Spring IoC容器来管理Bean之间的依赖关系。该方式从Spring框架的第一版开始提供支持。
2. 注解方式：从Spring 2.5版本开始提供支持，可以通过在Bean类上使用注解来代替XML配置文件中的配置信息。通过在Bean类上加上相应的注解（如@Component, @Service, @Autowired等），将Bean注册到Spring IoC容器中，这样Spring IoC容器就可以管理这些Bean之间的依赖关系。
3. Java配置类方式：从Spring 3.0版本开始提供支持，通过Java类来定义Bean、Bean之间的依赖关系和配置信息，从而代替XML配置文件的方式。Java配置类是一种使用Java编写配置信息的方式，通过@Configuration、@Bean等注解来实现Bean和依赖关系的配置。

4.Spring IoC/DI总结

IoC容器

Spring IoC 容器使用多种形式的配置元数据。此配置元数据表示您作为应用程序开发人员如何告诉 Spring 容器实例化、配置和组装应用程 

IoC（Inversion of Control）控制反转

IoC 主要是针对对象的创建和调用控制而言的，也就是说，当应用程序需要使用一个对象时，不再是应用程序直接创建该对象，而是由 IoC 容器来创建和管理，即控制权由应用程序转移到 IoC 容器中，也就是“反转”了控制权。这种方式基本上是通过依赖查找的方式来实现的，即 IoC 容器维护着构成应用程序的对象，并负责创建这些对象。 

DI (Dependency Injection) 依赖注入

DI 是指在组件之间传递依赖关系的过程中，将依赖关系在容器内部进行处理，这样就不必在应用程序代码中硬编码对象之间的依赖关系，实现了对象之间的解耦合。在 Spring 中，DI 是通过 XML 配置文件或注解的方式实现的。它提供了三种形式的依赖注入：构造函数注入、Setter 方法注入和接口注入。 

四、IoC基于XML配置方式

1.Spring IoC/DI实现步骤

第一步：配置元数据（配置） 

配置元数据，既是编写交给SpringIoC容器管理组件的信息，配置方式有三种。

基于 XML 的配置元数据的基本结构：

<bean id="..." [1] class="..." [2]>  
    <!-- collaborators and configuration for this bean go here -->
  </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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="..." [1] class="..." [2]>  <!-- collaborators and configuration for this bean go here --></bean><bean id="..." class="..."><!-- collaborators and configuration for this bean go here --></bean><!-- more bean definitions go here -->
</beans>

第二步：实例化IoC容器

提供给 `ApplicationContext` 构造函数的位置路径是资源字符串地址，允许容器从各种外部资源（如本地文件系统、Java `CLASSPATH` 等）加载配置元数据。

我们应该选择一个合适的容器实现类，进行IoC容器的实例化工作：

//实例化ioc容器,读取外部配置文件,最终会在容器内进行ioc和di动作
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");

第三步：获取Bean(组件)

`ApplicationContext` 是一个高级工厂的接口，能够维护不同 bean 及其依赖项的注册表。通过使用方法 `T getBean(String name, Class<T> requiredType)` ，您可以检索 bean 的实例。

允许读取 Bean 定义并访问它们，如以下示例所示：

//创建ioc容器对象，指定配置文件，ioc也开始实例组件对象
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");
//获取ioc容器的组件对象
PetStoreService service = context.getBean("petStore", PetStoreService.class);
//使用组件对象
List<String> userList = service.getUsernameList();

2.配置元数据Bean组件

首先要知道一般我们实例化一个对象有四种方法，就是无参构造器，有参构造器，静态工厂还有非静态工厂。实例化的方法不同，我们ioc配置的方式就不同。

先添加spring框架依赖和测试依赖

<dependencies><!--spring context依赖--><!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.6</version></dependency><!--junit5测试--><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter-api</artifactId><version>5.3.1</version></dependency>
</dependencies>

2.1无参构造器

（1）准备组件类
public class Entity {public Entity() {}public void doWork(){System.out.println("Entity.doWork()");}
}
（2）编写配置文件
<?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--><bean id = "NoArgsConstruct" class = "com.ahao.Entity"/>
</beans>

id是组件的唯一标识

class组件类对应的全类路径 

2.2静态工厂

（1）准备组件类
public class StaticFactory {public static Entity getInstance(){return new Entity();}
}
（2）编写配置文件
<?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--><bean id = "staticFactory" class = "com.ahao.StaticFactory" factory-method = "getInstance"/>
</beans>

factory-method是创建对象的静态方法 ，静态工厂方法

2.3非静态工厂

（1）准备组件类
public class Factory {public Entity instance() {return new Entity();}}
（2）编写配置文件
<?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--><bean id="factory" class="com.ahao.Factory"/><bean id="Entity" factory-bean="factory" factory-method="instance"/>
</beans>

非静工厂的bean配置比较麻烦一点

要先配置工厂类的bean,再配置目标bean。

2.4有参构造器

（1）准备组件类
public class UserService {private UserDao userDao;private int age;private String name;public UserService(UserDao userDao) {this.userDao = userDao;}public UserService(int age , String name ,UserDao userDao) {this.userDao = userDao;this.age = age;this.name = name;}
}
（2）编写配置文件
<?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--><bean id="ArgsConstruct" class="com.ahao.UserService"><constructor-arg ref="userDao"/><constructor-arg name="name" value="ahao"/><constructor-arg name="age" value="18"/></bean><bean id="userDao" class="com.ahao.UserDao"/></beans>

constructor-arg是构造器的参数，ref代表类类型，要另外再声明一个bean。

基本类型就直接用name属性声明参数名，value属性来赋值。

另外一种配置，按坐标配置

<!-- 场景2: 多参数，可以按照相应构造函数的角标注入数据 index从0开始 构造函数(0,1,2....)
-->
<beans><bean id="userService" class="x.y.UserService"><!-- value直接注入基本类型值 --><constructor-arg index="1" value="赵伟风"/><constructor-arg index="2" ref="userDao"/><constructor-arg index="0"  value="18"/></bean><!-- 被引用类bean声明 --><bean id="userDao" class="x.y.UserDao"/>
</beans>

还有一种如果有组件类有Setter方法可以Setter配置

<bean id="simpleMovieLister" class="examples.SimpleMovieLister"><!-- setter方法，注入movieFinder对象的标识idname = 属性名  ref = 引用bean的id值--><property name="movieFinder" ref="movieFinder" /><!-- setter方法，注入基本数据类型movieNamename = 属性名 value= 基本类型值--><property name="movieName" value="消失的她"/>
</bean><bean id="movieFinder" class="examples.MovieFinder"/>

2.5配置Ioc的过程图解

一般默认是单例

3.实例化IoC容器

想要配置文件中声明组件类信息真正的进行实例化成Bean对象和形成Bean之间的引用关系，我们需要声明IoC容器对象，读取配置文件，实例化组件和关系维护的过程都是在IoC容器中实现的！

//方式1:实例化并且指定配置文件
//参数：String...locations 传入一个或者多个配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");//方式2:先实例化，再指定配置文件，最后刷新容器触发Bean实例化动作 [springmvc源码和contextLoadListener源码方式]  
ApplicationContext context = new ClassPathXmlApplicationContext();   
//设置配置配置文件,方法参数为可变参数,可以设置一个或者多个配置
iocContainer1.setConfigLocations("services.xml", "daos.xml");
//后配置的文件,需要调用refresh方法,触发刷新配置
iocContainer1.refresh();

4.获取Bean

4.1根据ID

//没有指定类型,返回为Object,需要类型转化!
HappyComponent happyComponent = (HappyComponent) iocContainer.getBean("bean的id标识");//使用组件对象        
happyComponent.doWork();

4.2根据类类型

//根据类型获取,但是要求,同类型(当前类,或者之类,或者接口的实现类)只能有一个对象交给IoC容器管理
//配置两个或者以上出现: org.springframework.beans.factory.NoUniqueBeanDefinitionException 问题
HappyComponent happyComponent = iocContainer.getBean(HappyComponent.class);
happyComponent.doWork();

4.3根据ID和类类型

HappyComponent happyComponent = iocContainer.getBean("bean的id标识", HappyComponent.class);
happyComponent.doWork();根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，
只要返回的是true就可以认定为和类型匹配，能够获取到。

五、Ioc高级特性

1.生命周期（配置周期方法）

我们可以在组件类中定义方法，然后当IoC容器实例化和销毁组件对象的时候进行调用！这两个方法我们成为生命周期方法！

类似于Servlet的init/destroy方法,我们可以在周期方法完成初始化和释放资源等工作。

1.1准备组件类并声明周期方法

public class BeanOne {//周期方法要求： 方法命名随意，但是要求方法必须是 public void 无形参列表public void init() {// 初始化逻辑}
}public class BeanTwo {public void cleanup() {// 释放资源逻辑}
}

1.2编写配置文件

<beans><bean id="beanOne" class="examples.BeanOne" init-method="init" /><bean id="beanTwo" class="examples.BeanTwo" destroy-method="cleanup" />
</beans>

2.作用域（主要是单例和多例）

`<bean` 标签声明Bean，只是将Bean的信息配置给SpringIoC容器！

在IoC容器中，这些`<bean`标签对应的信息转成Spring内部 `BeanDefinition` 对象，`BeanDefinition` 对象内，包含定义的信息（id,class,属性等等）！

这意味着，`BeanDefinition`与`类`概念一样，SpringIoC容器可以可以根据`BeanDefinition`对象反射创建多个Bean对象实例。

具体创建多少个Bean的实例对象，由Bean的作用域Scope属性指定！

2.1作用域可选值

取值含义创建对象的时机默认是否开启
singleton在 IOC 容器中，这个 bean 的对象始终为单实例IOC 容器初始化时是
prototype这个 bean 在 IOC 容器中有多个实例获取 bean 时否

 如果是在WebApplicationContext环境下还会有另外两个作用域（但不常用）：

取值含义创建对象的时机默认值
request请求范围内有效的实例每次请求否
session会话范围内有效的实例每次会话否

2.2配置scope范围

<!--bean的作用域 准备两个引用关系的组件类即可！！
-->
<!-- scope属性：取值singleton（默认值），bean在IOC容器中只有一个实例，IOC容器初始化时创建对象 -->
<!-- scope属性：取值prototype，bean在IOC容器中可以有多个实例，getBean()时创建对象 -->
<bean id="happyMachine8" scope="prototype" class="com.zhku.ioc.HappyMachine"><property name="machineName" value="happyMachine"/>
</bean><bean id="happyComponent8" scope="singleton" class="com.zhku.ioc.HappyComponent"><property name="componentName" value="happyComponent"/>
</bean>

3.FactoryBean

`FactoryBean` 接口是Spring IoC容器实例化逻辑的可插拔性点。

用于配置复杂的Bean对象，可以将创建过程存储在`FactoryBean` 的getObject方法！

`FactoryBean<T>` 接口提供三种方法：

- `T getObject()`: 

    返回此工厂创建的对象的实例。该返回值会被存储到IoC容器！
- `boolean isSingleton()`: 

    如果此 `FactoryBean` 返回单例，则返回 `true` ，否则返回 `false` 。此方法的默认实现返回 `true` （注意，lombok插件使用，可能影响效果）。
- `Class<?> getObjectType()`: 返回 `getObject()` 方法返回的对象类型，如果事先不知道类型，则返回 `null` 。

3.1准备实现类

// 实现FactoryBean接口时需要指定泛型
// 泛型类型就是当前工厂要生产的对象的类型
public class HappyFactoryBean implements FactoryBean<HappyMachine> {private String machineName;public String getMachineName() {return machineName;}public void setMachineName(String machineName) {this.machineName = machineName;}@Overridepublic HappyMachine getObject() throws Exception {// 方法内部模拟创建、设置一个对象的复杂过程HappyMachine happyMachine = new HappyMachine();happyMachine.setMachineName(this.machineName);return happyMachine;}@Overridepublic Class<?> getObjectType() {// 返回要生产的对象的类型return HappyMachine.class;}
}

 3.2配置FactoryBean实现类

<!-- FactoryBean机制 -->
<!-- 这个bean标签中class属性指定的是HappyFactoryBean，但是将来从这里获取的bean是HappyMachine对象 -->
<bean id="happyMachine7" class="com.zhku.ioc.HappyFactoryBean"><!-- property标签仍然可以用来通过setXxx()方法给属性赋值 --><property name="machineName" value="iceCreamMachine"/>
</bean>

3.3实现通过FactoryBean实现类获取Bean

@Test
public void testExperiment07()  {ApplicationContext iocContainer = new ClassPathXmlApplicationContext("spring-bean-07.xml");//注意: 直接根据声明FactoryBean的id,获取的是getObject方法返回的对象HappyMachine happyMachine = iocContainer.getBean("happyMachine7",HappyMachine.class);System.out.println("happyMachine = " + happyMachine);//如果想要获取FactoryBean对象, 直接在id前添加&符号即可!  &happyMachine7 这是一种固定的约束Object bean = iocContainer.getBean("&happyMachine7");System.out.println("bean = " + bean);
}

3.4对比FactoryBean和BeanFactory

**FactoryBean **是 Spring 中一种特殊的 bean，可以在 getObject() 工厂方法自定义的逻辑创建Bean！是一种能够生产其他 Bean 的 Bean。FactoryBean 在容器启动时被创建，而在实际使用时则是通过调用 getObject() 方法来得到其所生产的 Bean。因此，FactoryBean 可以自定义任何所需的初始化逻辑，生产出一些定制化的 bean。

一般情况下，整合第三方框架，都是通过定义FactoryBean实现！！！

**BeanFactory** 是 Spring 框架的基础，其作为一个顶级接口定义了容器的基本行为，例如管理 bean 的生命周期、配置文件的加载和解析、bean 的装配和依赖注入等。BeanFactory 接口提供了访问 bean 的方式，例如 getBean() 方法获取指定的 bean 实例。它可以从不同的来源（例如 Mysql 数据库、XML 文件、Java 配置类等）获取 bean 定义，并将其转换为 bean 实例。同时，BeanFactory 还包含很多子类（例如，ApplicationContext 接口）提供了额外的强大功能。

总的来说，FactoryBean 和 BeanFactory 的区别主要在于前者是用于创建 bean 的接口，它提供了更加灵活的初始化定制功能，而后者是用于管理 bean 的框架基础接口，提供了基本的容器功能和 bean 生命周期管理。

六、Ioc基于注解方式配置

1.Bean注解标记和扫描

1.1注解标记

和 XML 配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。

本质上：所有一切的操作都是 Java 代码来完成的，XML 和注解只是告诉框架中的 Java 代码如何执行。

1.2扫描注解

Spring 为了知道程序员在哪些地方标记了什么注解，就需要通过扫描的方式，来进行检测。然后根据注解进行后续操作。

1.3基本注解

Spring 提供了以下多个注解，这些注解可以直接标注在 Java 类上，将它们定义成 Spring Bean。

注解说明
@Component该注解用于描述 Spring 中的 Bean，它是一个泛化的概念，仅仅表示容器中的一个组件（Bean），并且可以作用在应用的任何层次，例如 Service 层、Dao 层等。 使用时只需将该注解标注在相应类上即可。
@Repository该注解用于将数据访问层（Dao 层）的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Service该注解通常作用在业务层（Service 层），用于将业务层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。
@Controller该注解通常作用在控制层（如SpringMVC 的 Controller），用于将控制层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。

通过查看源码我们得知，@Controller、@Service、@Repository这三个注解只是在@Component注解的基础上起了三个新的名字。

对于Spring使用IOC容器管理这些组件来说没有区别，也就是语法层面没有区别。所以@Controller、@Service、@Repository这三个注解只是给开发人员看的，让我们能够便于分辨组件的作用。

注意：虽然它们本质上一样，但是为了代码的可读性、程序结构严谨！我们肯定不能随便胡乱标记。

1.4 编写扫描范围

（1）基本扫描
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"><!-- 配置自动扫描的包 --><!-- 1.包要精准,提高性能!2.会扫描指定的包和子包内容3.多个包可以使用,分割 例如: com.zhku.controller,com.zhku.service等--><context:component-scan base-package="com.zhku.components"/></beans>
（2）排除扫描
<!-- 情况三：指定不扫描的组件 -->
<context:component-scan base-package="com.zhku.components"><!-- context:exclude-filter标签：指定排除规则 --><!-- type属性：指定根据什么来进行排除，annotation取值表示根据注解来排除 --><!-- expression属性：指定排除规则的表达式，对于注解来说指定全类名即可 --><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
（3）指定扫描
<!-- 情况四：仅扫描指定的组件 -->
<!-- 仅扫描 = 关闭默认规则 + 追加规则 -->
<!-- use-default-filters属性：取值false表示关闭默认扫描规则 -->
<context:component-scan base-package="com.zhku.ioc.components" use-default-filters="false"><!-- context:include-filter标签：指定在原有扫描规则的基础上追加的规则 --><context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

1.5组件BeanName问题

在我们使用 XML 方式管理 bean 的时候，每个 bean 都有一个唯一标识——id 属性的值，便于在其他地方引用。现在使用注解后，每个组件仍然应该有一个唯一标识。

默认情况：

类名首字母小写就是 bean 的 id。例如：SoldierController 类对应的 bean 的 id 就是 soldierController。

也可以使用value属性指定：

@Controller(value = "tianDog")
public class SoldierController {
}

 2.Bean作用域和周期方法注解

2.1周期方法注解

public class BeanOne {//周期方法要求： 方法命名随意，但是要求方法必须是 public void 无形参列表@PostConstruct  //注解制指定初始化方法public void init() {// 初始化逻辑}
}public class BeanTwo {@PreDestroy //注解指定销毁方法public void cleanup() {// 释放资源逻辑}
}

  周期方法要求： 方法命名随意，但是要求方法必须是 public void 无形参列表
  @PostConstruct  //注解制指定初始化方法
  @PreDestroy //注解指定销毁方法
 

2.2作用域注解

@Scope(scopeName = ConfigurableBeanFactory.SCOPE_SINGLETON) //单例,默认值
@Scope(scopeName = ConfigurableBeanFactory.SCOPE_PROTOTYPE) //多例  二选一
public class BeanOne {//周期方法要求： 方法命名随意，但是要求方法必须是 public void 无形参列表@PostConstruct  //注解制指定初始化方法public void init() {// 初始化逻辑}
}

使用@Scope注解设置作用域为单例还是多例

@Scope(scopeName = ConfigurableBeanFactory.SCOPE_SINGLETON) //单例,默认值
@Scope(scopeName = ConfigurableBeanFactory.SCOPE_PROTOTYPE) //多例  二选一

3.Bean自动装配注解

3.1使用

@Controller(value = "tianDog")
public class SoldierController {@Autowired@Qualifier(value = "maomiService222")private SoldierService soldierService;public void getMessage() {soldierService.getMessage();}}

 @Autowired是自动装配注解

@Qualifier指明指定的id的bean

3.2标记位置

（1）成员变量
@Service("smallDog")
public class SoldierService {@Autowiredprivate SoldierDao soldierDao;public void getMessage() {soldierDao.getMessage();}
}
（2）构造器
@Controller(value = "tianDog")
public class SoldierController {private SoldierService soldierService;@Autowiredpublic SoldierController(SoldierService soldierService) {this.soldierService = soldierService;}……
（3）setter方法
@Controller(value = "tianDog")
public class SoldierController {private SoldierService soldierService;@Autowiredpublic void setSoldierService(SoldierService soldierService) {this.soldierService = soldierService;}……

3.3装配流程

4.基本类型属性装配注解

@Value 通常用于注入外部化属性

4.1先声明外部文件

创建文件application.properties

catalog.name=MovieCatalog

4.2编写配置文件

<!-- 引入外部配置文件-->
<context:property-placeholder location="application.properties" />

4.3@Value注解读取配置

@Component
public class CommonComponent {/*** 情况1: ${key} 取外部配置key对应的值!* 情况2: ${key:defaultValue} 没有key,可以给与默认值*///@Value("${catalog.name}")@Value("${catalog:hahaha}")private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}
}

七、Ioc基于配置类方式配置 

配置类的方式需要配合注解方式进行，不完全是配置类或注解。配置类简单一点理解就是，配置一个类来替代对接外部文件application.properties的Ioc配置文件xml。

1.创建一个配置类

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;//标注当前类是配置类，替代application.xml    
@Configuration
//使用注解读取外部配置，替代 <context:property-placeholder标签
@PropertySource("classpath:application.properties")
//使用@ComponentScan注解,可以配置扫描包,替代<context:component-scan标签
@ComponentScan(basePackages = {"com.zhku.components"})
public class MyConfiguration {}

使用@Configuration注解写在类的上面，标明该类是配置类。

使用@PropertySource注解读取外部文件，替代Ioc配置文件中的 <context:property-placeholder标签
使用@ComponentScan注解,可以配置扫描包,替代<context:component-scan标签

测试创建IoC容器

// AnnotationConfigApplicationContext 根据配置类创建 IOC 容器对象
ApplicationContext iocContainerAnnotation = 
new AnnotationConfigApplicationContext(MyConfiguration.class);

 可以使用 no-arg 构造函数实例化 AnnotationConfigApplicationContext ，然后使用 register() 方法对其进行配置。此方法在以编程方式生成 AnnotationConfigApplicationContext 时特别有用。以下示例演示如何执行此操作：

// AnnotationConfigApplicationContext-IOC容器对象
ApplicationContext iocContainerAnnotation = 
new AnnotationConfigApplicationContext();
//外部设置配置类
iocContainerAnnotation.register(MyConfiguration.class);
//刷新后方可生效！！
iocContainerAnnotation.refresh();

2.配置jar包组件

第三方jar包的类，添加到ioc容器，无法使用@Component等相关注解！因为源码jar包内容为只读模式！ 

//标注当前类是配置类，替代application.xml    
@Configuration
//引入jdbc.properties文件
@PropertySource({"classpath:application.properties","classpath:jdbc.properties"})
@ComponentScan(basePackages = {"com.zhku.components"})
public class MyConfiguration {//如果第三方类进行IoC管理,无法直接使用@Component相关注解//解决方案: xml方式可以使用<bean标签//解决方案: 配置类方式,可以使用方法返回值+@Bean注解@Beanpublic DataSource createDataSource(@Value("${jdbc.user}") String username,@Value("${jdbc.password}")String password,@Value("${jdbc.url}")String url,@Value("${jdbc.driver}")String driverClassName){//使用Java代码实例化DruidDataSource dataSource = new DruidDataSource();dataSource.setUsername(username);dataSource.setPassword(password);dataSource.setUrl(url);dataSource.setDriverClassName(driverClassName);//返回结果即可return dataSource;}
}

@Bean 注释用于指示方法实例化、配置和初始化要由 Spring IoC 容器管理的新对象。对于那些熟悉 Spring 的 XML 配置的人来说， @Bean 注释与 元素起着相同的作用。                                                                                            

3.@Bean注解细节

3.1BeanName问题

@Bean注解源码 

public @interface Bean {//前两个注解可以指定Bean的标识@AliasFor("name")String[] value() default {};@AliasFor("value")String[] name() default {};//autowireCandidate 属性来指示该 Bean 是否候选用于自动装配。//autowireCandidate 属性默认值为 true，表示该 Bean 是一个默认的装配目标，//可被候选用于自动装配。如果将 autowireCandidate 属性设置为 false，则说明该 Bean 不是默认的装配目标，不会被候选用于自动装配。boolean autowireCandidate() default true;//指定初始化方法String initMethod() default "";//指定销毁方法String destroyMethod() default "(inferred)";
}

指定@Bean的名称：

@Configuration
public class AppConfig {@Bean("myThing") //指定名称public Thing thing() {return new Thing();}
}

@Bean 注释注释方法。使用此方法在指定为方法返回值的类型的 ApplicationContext 中注册 Bean 定义。缺省情况下，Bean 名称与方法名称相同。

3.2初始化和销毁方法指定 

public class BeanOne {public void init() {// initialization logic}
}public class BeanTwo {public void cleanup() {// destruction logic}
}@Configuration
public class AppConfig {@Bean(initMethod = "init")public BeanOne beanOne() {return new BeanOne();}@Bean(destroyMethod = "cleanup")public BeanTwo beanTwo() {return new BeanTwo();}
}

3.3Scope作用域

可以指定使用 @Bean 注释定义的 bean 应具有特定范围。您可以使用在 Bean 作用域部分中指定的任何标准作用域。

默认作用域为 singleton ，但您可以使用 @Scope 注释覆盖此范围，如以下示例所示：

@Configuration
public class MyConfiguration {@Bean@Scope("prototype")public Encryptor encryptor() {// ...}
}

3.4java配置类实现（两bean依赖）

（1）直接方法引用

直接调用方法返回 Bean 实例：在一个 @Bean 方法中直接调用其他 @Bean 方法来获取 Bean 实例，虽然是方法调用，也是通过IoC容器获取对应的Bean，例如：

@Configuration
public class JavaConfig {@Beanpublic HappyMachine happyMachine(){return new HappyMachine();}@Beanpublic HappyComponent happyComponent(){HappyComponent happyComponent = new HappyComponent();//直接调用方法即可! happyComponent.setHappyMachine(happyMachine());return happyComponent;}}
（2）参数引用

参数引用法：通过方法参数传递 Bean 实例的引用来解决 Bean 实例之间的依赖关系，例如：

/*** projectName: com.atguigu.config* description: 配置HappyComponent和HappyMachine关系*/@Configuration
public class JavaConfig {@Beanpublic HappyMachine happyMachine(){return new HappyMachine();}/*** 可以直接在形参列表接收IoC容器中的Bean!*    情况1: 直接指定类型即可*    情况2: 如果有多个bean,(HappyMachine 名称 ) 形参名称等于要指定的bean名称!*           例如:*               @Bean*               public Foo foo1(){*                   return new Foo();*               }*               @Bean*               public Foo foo2(){*                   return new Foo()*               }*               @Bean*               public Component component(Foo foo1 / foo2 通过此处指定引入的bean)*/@Beanpublic HappyComponent happyComponent(HappyMachine happyMachine){HappyComponent happyComponent = new HappyComponent();//赋值happyComponent.setHappyMachine(happyMachine);return happyComponent;}}

4.配置类加载另一个配置类

可以使用@import注解实现 

@Configuration
public class ConfigA {@Beanpublic A a() {return new A();}
}@Configuration
@Import(ConfigA.class)
public class ConfigB {@Beanpublic B b() {return new B();}
}

现在，在实例化上下文时不需要同时指定 ConfigA.class 和 ConfigB.class ，只需显式提供 ConfigB ，如以下示例所示：

public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);// now both beans A and B will be available...A a = ctx.getBean(A.class);B b = ctx.getBean(B.class);
}

八、三种配置方式总结

1.纯XML配置方式

（1）所有内容写到xml格式配置文件中

（2）声明bean通过<bean标签

（3）<bean标签包含基本信息（id,class）和属性信息 <property name value / ref

（4）引入外部的properties文件可以通过<context:property-placeholder

（5）IoC具体容器实现选择ClassPathXmlApplicationContext对象

2.XML+注解

（1）注解负责标记IoC的类和进行属性装配

（2）xml文件依然需要，需要通过<context:component-scan标签指定注解范围

（3）标记IoC注解：@Component,@Service,@Controller,@Repository

（4）标记DI注解：@Autowired @Qualifier @Resource @Value

（5）IoC具体容器实现选择ClassPathXmlApplicationContext对象

3.配置类+注解

（1）完全注解方式指的是去掉xml文件，使用配置类 + 注解实现

（2）xml文件替换成使用@Configuration注解标记的类

（3）标记IoC注解：@Component,@Service,@Controller,@Repository

（4）标记DI注解：@Autowired @Qualifier @Resource @Value

（5）<context:component-scan标签指定注解范围使用@ComponentScan(basePackages = {"com.atguigu.components"})替代

（6）<context:property-placeholder引入外部配置文件使用@PropertySource({"classpath:application.properties","classpath:jdbc.properties"})替代

（7）<bean 标签使用@Bean注解和方法实现

（8）IoC具体容器实现选择AnnotationConfigApplicationContext对象

http://www.dtcms.com/wzjs/42999.html

相关文章：

  • 深圳网站建设招聘域名怎么注册
  • 有做网站设计吗近三年成功的营销案例
  • 方圆网站建设网络营销是什么工作
  • 专业开发网站的公司太原做网络推广的公司
  • 网站建设-应酷百度关键词搜索量统计
  • 佛山网站建设业务员怎么建网址
  • 个人网站带后台源码友情链接工具
  • 0731网站windows系统优化软件排行榜
  • 设计师网址推荐培训机构seo
  • 基于php的网站开发英文文献厦门零基础学seo
  • 郴州网站建设企业国内seo排名分析主要针对百度
  • 广州建筑信息平台南宁百度seo
  • 南昌网站设计手机网站自助建站系统
  • 网站怎么做支付宝付款信息流广告
  • 上海做网站的价格昆明seo培训
  • 厦门微信网站建设seo关键词优化最多可以添加几个词
  • 代刷网站推广链接快手app排名优化
  • 温州网站建设服务中心重庆seo研究中心
  • 如何自己做免费网站刚刚济南发通知
  • 公司网站维护好做吗百度账号登录不了
  • html素材免费下载西安seo技术培训班
  • 一做特卖的网站北京网站建设公司案例
  • 北京住房和城乡建设网官网余姚网站seo运营
  • 便宜的做网站公司经典广告语
  • 广州做家教的网站网页设计自学要多久
  • 上海旅游网站建设广告推广语
  • 做a短视频网站seo是什么?
  • 网站商城建设合同百度一下首页网址
  • 免费建站网站一级熟熟俱乐一级夫妇性活五月天噪综合怎么才能创建一个网站
  • 怎么做网站首页图片不会失真seo软文推广