网站建设安装部署必须买吗做那个网站比较好

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

网站建设安装部署必须买吗,做那个网站比较好,南充房产管理网,js检测网站是否能打开1. 容器#xff1a;IOC IoC 是 Inversion of Control 的简写#xff0c;译为“控制反转”#xff0c;它不是一门技术#xff0c;而是一种设计思想#xff0c;是一个重要的面向对象编程法则#xff0c;能够指导我们如何设计出松耦合、更优良的程序 Spring 通过 IoC 容器来…1. 容器IOC IoC 是 Inversion of Control 的简写译为“控制反转”它不是一门技术而是一种设计思想是一个重要的面向对象编程法则能够指导我们如何设计出松耦合、更优良的程序 Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化控制对象与对象之间的依赖关系。我们将由 IoC 容器管理的 Java 对象称为 Spring Bean它与使用关键字 new 创建的 Java 对象没有任何区别 IoC 容器是 Spring 框架中最重要的核心组件之一它贯穿了 Spring 从诞生到成长的整个过程 1.1 IOC容器 1.1.1 控制反转 控制反转是一种思想。控制反转是为了降低程序耦合度提高程序扩展力。控制反转反转的是什么 将对象的创建权利交出去交给第三方容器负责。将对象和对象之间关系的维护权交出去交给第三方容器负责。 控制反转这种思想如何实现呢 DIDependency Injection依赖注入
1.1.2 依赖注入 DIDependency Injection依赖注入依赖注入实现了控制反转的思想。 依赖注入 指Spring创建对象的过程中将对象依赖属性通过配置进行注入 依赖注入常见的实现方式包括两种 第一种set注入第二种构造注入
所以结论是IOC 就是一种控制反转的思想 而 DI 是对IoC的一种具体实现 Bean管理说的是Bean对象的创建以及Bean对象中属性的赋值或者叫做Bean对象之间关系的维护。 1.1.3 IOC容器在Spring的实现 Spring 的 IoC 容器就是 IoC思想的一个落地的产品实现。IoC容器中管理的组件也叫做 bean。在创建 bean 之前首先需要创建IoC 容器。Spring 提供了IoC 容器的两种实现方式 ①BeanFactory 这是 IoC 容器的基本实现是 Spring 内部使用的接口。面向 Spring 本身不提供给开发人员使用。 ②ApplicationContext BeanFactory 的子接口提供了更多高级特性。面向 Spring 的使用者几乎所有场合都使用 ApplicationContext 而不是底层的 BeanFactory。 ③ApplicationContext的主要实现类
类型名简介ClassPathXmlApplicationContext通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象FileSystemXmlApplicationContext通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象ConfigurableApplicationContextApplicationContext 的子接口包含一些扩展方法 refresh() 和 close() 让 ApplicationContext 具有启动、关闭和刷新上下文的能力。WebApplicationContext专门为 Web 应用准备基于 Web 环境创建 IOC 容器对象并将对象引入存入 ServletContext 域中。 3.2 基于XML管理bean 3.2.1、搭建子模块spring6-ioc-xml 添加依赖 dependencies!–spring context依赖–!–当你引入Spring Context依赖之后表示将Spring的基础依赖引入了–dependencygroupIdorg.springframework/groupIdartifactIdspring-context/artifactIdversion6.0.3/version/dependency!–junit5测试–dependencygroupIdorg.junit.jupiter/groupIdartifactIdjunit-jupiter-api/artifactIdversion5.3.1/version/dependency!–log4j2的依赖–dependencygroupIdorg.apache.logging.log4j/groupIdartifactIdlog4j-core/artifactIdversion2.19.0/version/dependencydependencygroupIdorg.apache.logging.log4j/groupIdartifactIdlog4j-slf4j2-impl/artifactIdversion2.19.0/version/dependency /dependencies3.2.2 获取bean 方式一根据id获取 由于 id 属性指定了 bean 的唯一标识所以根据 bean 标签的 id 属性可以精确获取到一个组件对象。上个实验中我们使用的就是这种 方式二根据类型获取 Test public void testHelloWorld1(){ApplicationContext ac new ClassPathXmlApplicationContext(beans.xml);//当根据类型获取bean时要求IOC容器中指定类型的bean有且只能有一个HelloWorld bean ac.getBean(HelloWorld.class);bean.sayHello(); }方式三根据id和类型 Test public void testHelloWorld2(){ApplicationContext ac new ClassPathXmlApplicationContext(beans.xml);HelloWorld bean ac.getBean(helloworld, HelloWorld.class);bean.sayHello(); }3.2.3 依赖注入之setter注入 创建User类 package com.gdhd.domain;public class User {private String name;private Integer age;public String getName() {return name;}public void setName(String name) {this.name name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age age;}Overridepublic String toString() {return User{ name name \ , age age };} } 配置bean时为属性赋值 bean iduser classcom.gdhd.domin.User!– property标签通过组件类的setXxx()方法给组件对象设置属性 –!– name属性指定属性名这个属性名是getXxx()、setXxx()方法定义的和成员变量无关 –!– value属性指定属性值 –property namename value张三/propertyproperty nameage value23/property /bean测试 public class UserTest {Testpublic void name(){ApplicationContext acnew ClassPathXmlApplicationContext (bean.xml);User user (User) ac.getBean(user);System.out.println(user);} } }3.2.4 依赖注入之构造器注入 在User类添加有参构造 public User(String name, Integer age) {this.name name;this.age age;} 配置Bean bean iduser classcom.gdhd.domain.User!– constructor标签通过组件类的构造器方法给组件对象设置属性 –!–valus:赋值name:指定参数名index指定参数所在位置的索引(从0开始)–constructor-arg value小道/constructor-argconstructor-arg value30/constructor-arg/bean测试 public class UserTest {Testpublic void name(){ApplicationContext acnew ClassPathXmlApplicationContext (bean.xml);User user (User) ac.getBean(user);System.out.println(user);} }3.2.5 特殊值处理 什么是字面量 int a10 声明一个变量a,初始化为10此时a就不代表字母a了而是作为一个变量的名字当我们引用a的时候我们实际上拿到的值是10 而如果a是带引号的‘a’那么它现在不是一个变量它就是代表a这个字母本身这就是字面量。所以字面量没有引申含义就是我们看到的这个数据本身 !– 使用value属性给bean的属性赋值时Spring会把value属性的值看做字面量 – property namename value张三/null值 property namenamenull / /propertyxml实体 !– 小于号在XML文档中用来定义标签的开始不能随便使用 – !– 解决方案一使用XML实体来代替 – property nameexpression valuea lt; b/CDATA节 property nameexpression!– 解决方案二使用CDATA节 –!– CDATA中的C代表Character是文本、字符的含义CDATA就表示纯文本数据 –!– XML解析器看到CDATA节就知道这里是纯文本就不会当作XML标签或属性来解析 –!– 所以CDATA节中写什么符号都随意 –value![CDATA[a b]]/value /property3.2.6 为对象属性赋值 创建Dog类 package com.gdhd.domain;public class Dog {private String name;private Integer age;public String getName() {return name;}public void setName(String name) {this.name name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age age;}Overridepublic String toString() {return Dog{ name name \ , age age };}public Dog(String name, Integer age) {this.name name;this.age age;}public Dog() {}} 修改User类 private Dog dog;public String getName() {return name;}public Dog getDog() {return dog;}public void setDog(Dog dog) {this.dog dog;}方式一引用外部的bean 配置Dog类的bean bean iddog classcom.gdhd.domain.Dogproperty namename value旺财/propertyproperty nameage value16/property/bean为User中的dog属性赋值 property namename value小道/propertyproperty nameage value15/property!– ref属性引用IOC容器中某个bean的id将所对应的bean为属性赋值 –property namedog refdog/property方式二内部bean property namename value小道/propertyproperty nameage value15/property!– 在一个bean中再声明一个bean就是内部bean –!– 内部bean只能用于给属性赋值不能在外部通过IOC容器获取因此可以省略id属性 –property namedog bean iddog classcom.gdhd.domain.Dogproperty namename value旺财/propertyproperty nameage value16/property/bean/property方式三级联属性赋值 bean iduser classcom.gdhd.domain.Userproperty namename value小道/propertyproperty nameage value15/propertyproperty namedog refdogOne/propertyproperty namedog.name value旺财/propertyproperty namedog.age value145/property!– constructor-arg nameage value15/constructor-arg– !– constructor-arg namename value30/constructor-arg–/beanbean iddogOne classcom.gdhd.domain.Dog/bean3.2.7 为数组类型属性赋值 修改User类 private String[] hobbies;public String[] getHobbies() {return hobbies; }public void setHobbies(String[] hobbies) {this.hobbies hobbies; }配置Bean property namehobbies arrayvalue喝酒/valuevalue看书/value/array/property3.2.8 为集合类型属性赋值 为List集合类型属性赋值 修改User类 private ListDog dogs;public ListDog getDogs() {return dogs;}public void setDogs(ListDog dogs) {this.dogs dogs;}配置bean property namedogslistref beandogsOne/refref beandogsTwo/refref beandogsThree/ref/list/property若为Set集合类型属性赋值只需要将其中的list标签改为set标签即可为Map集合类型属性赋值 创建教师类Teacher package com.gdhd.domain;public class Teacher {private Integer teachId;private String teachName;public Integer getTeachId() {return teachId;}public void setTeachId(Integer teachId) {this.teachId teachId;}public String getTeachName() {return teachName;}public void setTeachName(String teachName) {this.teachName teachName;}Overridepublic String toString() {return Teacher{ teachId teachId , teachName teachName \ };} } 创建Student类 package com.gdhd.domain;import java.util.Map;public class Student {private String name;private Integer age;private MapString,Teacher teacherMap;public String getName() {return name;}public void setName(String name) {this.name name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age age;}public MapString, Teacher getTeacherMap() {return teacherMap;}public void setTeacherMap(MapString, Teacher teacherMap) {this.teacherMap teacherMap;}Overridepublic String toString() {return Student{ name name \ , age age , teacherMap teacherMap };} } 配置bean bean idteacherOne classcom.gdhd.domain.Teacherproperty nameteachId value1/propertyproperty nameteachName value语文老师/property/beanbean idteacherFirst classcom.gdhd.domain.Teacherproperty nameteachId value1/propertyproperty nameteachName value数学老师/property/beanbean idstudent classcom.gdhd.domain.Studentproperty namename value小王/propertyproperty nameage value24/propertyproperty nameteacherMap mapentrykeyvalue1001/value/keyref beanteacherOne/ref/entryentrykeyvalue1002/value/keyref beanteacherFirst/ref/entry/map/property/bean引用集合类型的bean 创建Lesson类 package com.gdhd.domain;public class Lesson {private String LessonName;public String getLessonName() {return LessonName;}public void setLessonName(String lesson) {LessonName lesson;}Overridepublic String toString() {return Lesson{ Lesson LessonName \ };} } 修改Student类 private ListLesson lessons;public ListLesson getLessons() {return lessons;}public void setLessons(ListLesson lessons) {this.lessons lessons;}引用命名空间 使用util:list、util:map标签必须引入相应的命名空间 ?xml version1.0 encodingUTF-8? beans xmlnshttp://www.springframework.org/schema/beansxmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexmlns:utilhttp://www.springframework.org/schema/utilxsi:schemaLocationhttp://www.springframework.org/schema/utilhttp://www.springframework.org/schema/util/spring-util.xsdhttp://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd配置bean ?xml version1.0 encodingUTF-8? beans xmlnshttp://www.springframework.org/schema/beansxmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexmlns:utilhttp://www.springframework.org/schema/utilxsi:schemaLocationhttp://www.springframework.org/schema/utilhttp://www.springframework.org/schema/util/spring-util.xsdhttp://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd !– 1 创建三个对象– !– 2 注入普通类型属性– !– 3 使用util:类型 定义– !– 4 在学生bean引入util:类型定义bean完成list、map类型属性注入– !– list属性注入–util:list idlessonref beanlessonOne/refref beanlessonTow/ref/util:listbean idlessonOne classcom.gdhd.domain.Lessonproperty namelessonName valuejava开发/property/beanbean idlessonTow classcom.gdhd.domain.Lessonproperty namelessonName value计算机网络/property/bean !– map类型属性注入–util:map idmapentrykeyvalue1001/value/keyref beanTeacherOne/ref/entryentrykeyvalue1002/value/keyref beanTeacherTow/ref/entry/util:mapbean idTeacherOne classcom.gdhd.domain.Teacherproperty nameteachId value1001/propertyproperty nameteachName value王城老师/property/beanbean idTeacherTow classcom.gdhd.domain.Teacherproperty nameteachId value1001/propertyproperty nameteachName value王城老师/property/beanbean idstudent classcom.gdhd.domain.Studentproperty namename value小王/propertyproperty nameage value12/propertyproperty namelessons reflesson/propertyproperty nameteacherMap refmap/property/bean /beans3.2.9 引入外部属性文件 加入依赖 !– MySQL驱动 – dependencygroupIdmysql/groupIdartifactIdmysql-connector-java/artifactIdversion8.0.30/version /dependency!– 数据源 – dependencygroupIdcom.alibaba/groupIdartifactIddruid/artifactIdversion1.2.15/version /dependency创建外部属性文件
jdbc.userroot jdbc.passwordatguigu jdbc.urljdbc:mysql://localhost:3306/ssm?serverTimezoneUTC jdbc.drivercom.mysql.cj.jdbc.Driver引入属性文件 引入context 名称空间
?xml version1.0 encodingUTF-8? beans xmlnshttp://www.springframework.org/schema/beansxmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexmlns:contexthttp://www.springframework.org/schema/contextxsi:schemaLocationhttp://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd/beans!– 引入外部属性文件 – context:property-placeholder locationclasspath:jdbc.properties/注意在使用 context:property-placeholder 元素加载外包配置文件功能前首先需要在 XML 配置的一级标签 beans 中添加 context 相关的约束。 配置bean bean iddruidDataSource classcom.alibaba.druid.pool.DruidDataSourceproperty nameurl value\({jdbc.url}/property namedriverClassName value\){jdbc.driver}/property nameusername value\({jdbc.user}/property namepassword value\){jdbc.password}/ /bean测试 Test public void testDataSource() throws SQLException {ApplicationContext ac new ClassPathXmlApplicationContext(spring-datasource.xml);DataSource dataSource ac.getBean(DataSource.class);Connection connection dataSource.getConnection();System.out.println(connection); }3.2.10 bean的作用域 概念 在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围取值含义参照下表
取值含义创建对象的时机singleton默认在IOC容器中这个bean的对象始终为单实例IOC容器初始化时prototype这个bean在IOC容器中有多个实例获取bean时 如果是在WebApplicationContext环境下还会有另外几个作用域但不常用 取值含义request在一个请求范围内有效session在一个会话范围内有效创建User类 public class User {private Integer id;private String username;private String password;private Integer age;public User() {}public User(Integer id, String username, String password, Integer age) {this.id id;this.username username;this.password password;this.age age;}public Integer getId() {return id;}public void setId(Integer id) {this.id id;}public String getUsername() {return username;}public void setUsername(String username) {this.username username;}public String getPassword() {return password;}public void setPassword(String password) {this.password password;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age age;}Overridepublic String toString() {return User{ id id , username username \ , password password \ , age age };} }配置Bean !– scope属性取值singleton默认值bean在IOC容器中只有一个实例IOC容器初始化时创建对象 – !– scope属性取值prototypebean在IOC容器中可以有多个实例getBean()时创建对象 – bean classcom.atguigu.spring6.bean.User scopeprototype/bean测试 Test public void testBeanScope(){ApplicationContext ac new ClassPathXmlApplicationContext(spring-scope.xml);User user1 ac.getBean(User.class);User user2 ac.getBean(User.class);System.out.println(user1user2); }3.2.11 Bean生命周期 ①具体的生命周期过程 bean对象创建调用无参构造器给bean对象设置属性bean的后置处理器初始化之前bean对象初始化需在配置bean时指定初始化方法bean的后置处理器初始化之后bean对象就绪可以使用bean对象销毁需在配置bean时指定销毁方法IOC容器关闭 2.修改User类 public class User {private Integer id;private String username;private String password;private Integer age;public User() {System.out.println(生命周期1、创建对象);}public User(Integer id, String username, String password, Integer age) {this.id id;this.username username;this.password password;this.age age;}public Integer getId() {return id;}public void setId(Integer id) {System.out.println(生命周期2、依赖注入);this.id id;}public String getUsername() {return username;}public void setUsername(String username) {this.username username;}public String getPassword() {return password;}public void setPassword(String password) {this.password password;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age age;}public void initMethod(){System.out.println(生命周期3、初始化);}public void destroyMethod(){System.out.println(生命周期5、销毁);}Overridepublic String toString() {return User{ id id , username username \ , password password \ , age age };} }配置bean !– 使用init-method属性指定初始化方法 – !– 使用destroy-method属性指定销毁方法 – bean classcom.atguigu.spring6.bean.User scopeprototype init-methodinitMethod destroy-methoddestroyMethodproperty nameid value1001/propertyproperty nameusername valueadmin/propertyproperty namepassword value123456/propertyproperty nameage value23/property /bean测试 Test public void testLife(){ClassPathXmlApplicationContext ac new ClassPathXmlApplicationContext(spring-lifecycle.xml);User bean ac.getBean(User.class);System.out.println(生命周期4、通过IOC容器获取bean并使用);ac.close(); }bean的后置处理器 bean的后置处理器会在生命周期的初始化前后添加额外的操作需要实现BeanPostProcessor接口且配置到IOC容器中需要注意的是bean后置处理器不是单独针对某一个bean生效而是针对IOC容器中所有bean都会执行创建bean的后置处理器
package com.atguigu.spring6.process;import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor; //实现BeanPostProcessor接口 public class MyBeanProcessor implements BeanPostProcessor {//在初始化之前执行Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println(☆☆☆ beanName bean);return bean;}//在初始化之后执行Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println(★★★ beanName bean);return bean;} }在IOC容器中配置后置处理器 !– bean的后置处理器要放入IOC容器才能生效 – bean idmyBeanProcessor classcom.atguigu.spring6.process.MyBeanProcessor/3.2.13 FactoryBean 简介 FactoryBean是Spring提供的一种整合第三方框架的常用机制。和普通的bean不同配置一个FactoryBean类型的bean在获取bean的时候得到的并不是class属性中配置的这个类的对象而是getObject()方法的返回值。通过这种机制Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来只把最简洁的使用界面展示给我们。将来我们整合Mybatis时Spring就是通过FactoryBean机制来帮我们创建SqlSessionFactory对象的。
/** Copyright 2002-2020 the original author or authors.** Licensed under the Apache License, Version 2.0 (the License);* you may not use this file except in compliance with the License.* You may obtain a copy of the License at** https://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an AS IS BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License./ package org.springframework.beans.factory;import org.springframework.lang.Nullable;/** Interface to be implemented by objects used within a {link BeanFactory} which* are themselves factories for individual objects. If a bean implements this* interface, it is used as a factory for an object to expose, not directly as a* bean instance that will be exposed itself.** pbNB: A bean that implements this interface cannot be used as a normal bean./b* A FactoryBean is defined in a bean style, but the object exposed for bean* references ({link #getObject()}) is always the object that it creates.** pFactoryBeans can support singletons and prototypes, and can either create* objects lazily on demand or eagerly on startup. The {link SmartFactoryBean}* interface allows for exposing more fine-grained behavioral metadata.** pThis interface is heavily used within the framework itself, for example for* the AOP {link org.springframework.aop.framework.ProxyFactoryBean} or the* {link org.springframework.jndi.JndiObjectFactoryBean}. It can be used for* custom components as well; however, this is only common for infrastructure code.** pb{code FactoryBean} is a programmatic contract. Implementations are not* supposed to rely on annotation-driven injection or other reflective facilities./b* {link #getObjectType()} {link #getObject()} invocations may arrive early in the* bootstrap process, even ahead of any post-processor setup. If you need access to* other beans, implement {link BeanFactoryAware} and obtain them programmatically.** pbThe container is only responsible for managing the lifecycle of the FactoryBean* instance, not the lifecycle of the objects created by the FactoryBean./b Therefore,* a destroy method on an exposed bean object (such as {link java.io.Closeable#close()}* will inot/i be called automatically. Instead, a FactoryBean should implement* {link DisposableBean} and delegate any such close call to the underlying object.** pFinally, FactoryBean objects participate in the containing BeanFactorys* synchronization of bean creation. There is usually no need for internal* synchronization other than for purposes of lazy initialization within the* FactoryBean itself (or the like).** author Rod Johnson* author Juergen Hoeller* since 08.03.2003* param T the bean type* see org.springframework.beans.factory.BeanFactory* see org.springframework.aop.framework.ProxyFactoryBean* see org.springframework.jndi.JndiObjectFactoryBean/ public interface FactoryBeanT {/** The name of an attribute that can be* {link org.springframework.core.AttributeAccessor#setAttribute set} on a* {link org.springframework.beans.factory.config.BeanDefinition} so that* factory beans can signal their object type when it cant be deduced from* the factory bean class.* since 5.2/String OBJECT_TYPE_ATTRIBUTE factoryBeanObjectType;/** Return an instance (possibly shared or independent) of the object* managed by this factory.* pAs with a {link BeanFactory}, this allows support for both the* Singleton and Prototype design pattern.* pIf this FactoryBean is not fully initialized yet at the time of* the call (for example because it is involved in a circular reference),* throw a corresponding {link FactoryBeanNotInitializedException}.* pAs of Spring 2.0, FactoryBeans are allowed to return {code null}* objects. The factory will consider this as normal value to be used; it* will not throw a FactoryBeanNotInitializedException in this case anymore.* FactoryBean implementations are encouraged to throw* FactoryBeanNotInitializedException themselves now, as appropriate.* return an instance of the bean (can be {code null})* throws Exception in case of creation errors* see FactoryBeanNotInitializedException/NullableT getObject() throws Exception;/** Return the type of object that this FactoryBean creates,* or {code null} if not known in advance.* pThis allows one to check for specific types of beans without* instantiating objects, for example on autowiring.* pIn the case of implementations that are creating a singleton object,* this method should try to avoid singleton creation as far as possible;* it should rather estimate the type in advance.* For prototypes, returning a meaningful type here is advisable too.* pThis method can be called ibefore/i this FactoryBean has* been fully initialized. It must not rely on state created during* initialization; of course, it can still use such state if available.* pbNOTE:/b Autowiring will simply ignore FactoryBeans that return* {code null} here. Therefore it is highly recommended to implement* this method properly, using the current state of the FactoryBean.* return the type of object that this FactoryBean creates,* or {code null} if not known at the time of the call* see ListableBeanFactory#getBeansOfType/NullableClass? getObjectType();/** Is the object managed by this factory a singleton? That is,* will {link #getObject()} always return the same object* (a reference that can be cached)?* pbNOTE:/b If a FactoryBean indicates to hold a singleton object,* the object returned from {code getObject()} might get cached* by the owning BeanFactory. Hence, do not return {code true}* unless the FactoryBean always exposes the same reference.* pThe singleton status of the FactoryBean itself will generally* be provided by the owning BeanFactory; usually, it has to be* defined as singleton there.* pbNOTE:/b This method returning {code false} does not* necessarily indicate that returned objects are independent instances.* An implementation of the extended {link SmartFactoryBean} interface* may explicitly indicate independent instances through its* {link SmartFactoryBean#isPrototype()} method. Plain {link FactoryBean}* implementations which do not implement this extended interface are* simply assumed to always return independent instances if the* {code isSingleton()} implementation returns {code false}.* pThe default implementation returns {code true}, since a* {code FactoryBean} typically manages a singleton instance.* return whether the exposed object is a singleton* see #getObject()* see SmartFactoryBean#isPrototype()*/default boolean isSingleton() {return true;} }创建类UserFactoryBean public class UserFactoryBean implements FactoryBeanUser {Overridepublic User getObject() throws Exception {return new User();}Overridepublic Class? getObjectType() {return User.class;} }配置bean bean iduser classcom.atguigu.spring6.bean.UserFactoryBean/bean测试 Test public void testUserFactoryBean(){//获取IOC容器ApplicationContext ac new ClassPathXmlApplicationContext(spring-factorybean.xml);User user (User) ac.getBean(user);System.out.println(user); }3.2.14 基于xml自动装配 自动装配 根据指定的策略在IOC容器中匹配某一个bean自动为指定的bean中所依赖的类类型或接口类型属性赋值 创建模拟 创建类UserController package com.atguigu.spring6.autowire.controller public class UserController {private UserService userService;public void setUserService(UserService userService) {this.userService userService;}public void saveUser(){userService.saveUser();}}创建接口UserService package com.atguigu.spring6.autowire.service public interface UserService {void saveUser();}创建类UserServiceImpl实现接口UserService package com.atguigu.spring6.autowire.service.impl public class UserServiceImpl implements UserService {private UserDao userDao;public void setUserDao(UserDao userDao) {this.userDao userDao;}Overridepublic void saveUser() {userDao.saveUser();}}创建接口UserDao package com.atguigu.spring6.autowire.dao public interface UserDao {void saveUser();}创建类UserDaoImpl实现接口UserDao package com.atguigu.spring6.autowire.dao.impl public class UserDaoImpl implements UserDao {Overridepublic void saveUser() {System.out.println(保存成功);}}配置Bean 使用bean标签的autowire属性设置自动装配效果 自动装配方式byType byType根据类型匹配IOC容器中的某个兼容类型的bean为属性自动赋值 若在IOC中没有任何一个兼容类型的bean能够为属性赋值则该属性不装配即值为默认值null 若在IOC中有多个兼容类型的bean能够为属性赋值则抛出异常NoUniqueBeanDefinitionException bean iduserController classcom.atguigu.spring6.autowire.controller.UserController autowirebyType/beanbean iduserService classcom.atguigu.spring6.autowire.service.impl.UserServiceImpl autowirebyType/beanbean iduserDao classcom.atguigu.spring6.autowire.dao.impl.UserDaoImpl/bean自动装配方式byName byName将自动装配的属性的属性名作为bean的id在IOC容器中匹配相对应的bean进行赋值 bean iduserController classcom.atguigu.spring6.autowire.controller.UserController autowirebyName/beanbean iduserService classcom.atguigu.spring6.autowire.service.impl.UserServiceImpl autowirebyName/bean bean iduserServiceImpl classcom.atguigu.spring6.autowire.service.impl.UserServiceImpl autowirebyName/beanbean iduserDao classcom.atguigu.spring6.autowire.dao.impl.UserDaoImpl/bean bean iduserDaoImpl classcom.atguigu.spring6.autowire.dao.impl.UserDaoImpl/bean测试 Test public void testAutoWireByXML(){ApplicationContext ac new ClassPathXmlApplicationContext(autowire-xml.xml);UserController userController ac.getBean(UserController.class);userController.saveUser(); }