3、IOC创建对象的方法（ioc创建的对象是单例还是多例）

　　本篇文章为你整理了3、IOC创建对象的方法（ioc创建的对象是单例还是多例）的详细内容，包含有ioc创建对象的三种方式 ioc创建的对象是单例还是多例 ioc创建过程创建ioc容器 3、IOC创建对象的方法，希望能帮助你了解 3、IOC创建对象的方法。

 !--别名，如果添加了别名，我们也可以使用别名取到这个对象--

　　 alias name="user" alias="userNew"/

　　4.2、Bean的配置

!--

　　 id: bean 的唯一标识符，也就是相当于我们学的对象名

　　 class： bean 对象所对应的全限定名：包名 + 类型

　　 name：也是别名, 而且name 可以同时取多个别名

　　 bean id="userT" name="user2 u2,u3;u4"

　　 property name="name" value="钟健学习"/

　　 /bean

　　4.3、import

　　
这个import一般用于团队开发使用，他可以将多个配置文件导入合并为一个，假设，现在项目有对人开发，将三人不同的开类需注册到不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！

 ?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

　　 https://www.springframework.org/schema/beans/spring-beans.xsd"

　　 bean id="student"

　　 !--第一种，普通注入，value--

　　 property name="name" value="钟健"/

　　 /bean

　　 /beans

　　
Student student = (Student) context.getBean("student");

　　 System.out.println(student.getName());

 ?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

　　 https://www.springframework.org/schema/beans/spring-beans.xsd"

　　 bean id="address"

　　 property name="address" value="北京"/

　　 /bean

　　 bean id="student"

　　 !--第一种，普通注入，value--

　　 property name="name" value="钟健"/

　　 !--第二种，bean注入，ref--

　　 property name="address" ref="address"/

　　 !--数组注入--

　　 property name="books"

　　 array

　　 value 红楼梦 /value

　　 value 水浒传 /value

　　 value 三国演义 /value

　　 value 西游记 /value

　　 /array

　　 /property

　　 !--List--

　　 property name="hobbys"

　　 list

　　 value 听歌 /value

　　 value 敲代码 /value

　　 value 看电影 /value

　　 /list

　　 /property

　　 !--Map--

　　 property name="card"

　　 map

　　 entry key="身份证" value="111111222222223333"/

　　 entry key="银行卡" value="123456789"/

　　 /map

　　 /property

　　 !--Set--

　　 property name="games"

　　 set

　　 value LOL /value

　　 value COS /value

　　 /set

　　 /property

　　 !--null--

　　 property name="wife"

　　 null/

　　 /property

　　 !--Properties--

　　 property name="info"

　　 props

　　 prop key="driver" 20230102 /prop

　　 prop key="url" 男 /prop

　　 prop key="username" root /prop

　　 prop key="password" 123456 /prop

　　 /props

　　 /property

　　 /bean

　　 /beans

 ?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:p="http://www.springframework.org/schema/p"

　　 xmlns:c="http://www.springframework.org/schema/c"

　　 xsi:schemaLocation="http://www.springframework.org/schema/beans

　　 https://www.springframework.org/schema/beans/spring-beans.xsd"

　　 !-- P命名空间注入，可以直接注入属性的值 property--

　　 bean id="user" p:name="钟健" p:age="18"/

　　 !-- c命名空间注入，通过构造器注入 construct-args--

　　 !--在User类中要有无参和有参构造器才可以使用 C 命名注入--

　　 bean id="user2" c:age="18" c:name="Jan"/

　　
public void test2(){

　　 ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");

　　
//User user = context.getBean("user", User.class);

　　 User user = context.getBean("user2", User.class);

　　 System.out.println(user);

　　
原型模式：每次从容器中get的时候，都会产生一个新对象！

 bean id="user2" c:age="18" c:name="Jan" scope="prototype"/

　　别特浪费资源，多线程可以使用原型模式

　　
自动配置是Spring满足bean依赖的一种方式

　　Spring会在上下文中自动寻找，并自动给bean装配属性！

　　在spring的三种配置方式：

　　在xml中显示的配置

　　在java中显示的配置

　　隐式的自动装配bean【重要】

　　6.1、测试

　　环境搭建：一个人有两个宠物！

　　原来的xml配置

 bean id="cat" /

　　 bean id="dog" /

　　 bean id="people"

　　 property name="name" value="钟健"/

　　 property name="cat" ref="cat"/

　　 property name="dog" ref="dog"/

　　 /bean

　　6.2、ByName自动装配

 bean id="cat" /

　　 bean id="dog" /

　　 ByName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的 bean id！

　　 ByType：会自动在容器上下文中查找，和自己对象属性类型相同的 bean ！

　　 bean id="people" autowire="byName"

　　 property name="name" value="钟健"/

　　 /bean

　　6.3、ByType自动装配

 bean /

　　 bean /

　　 ByName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的 bean id！

　　 ByType：会自动在容器上下文中查找，和自己对象属性类型相同的 bean ！

　　 bean id="people" autowire="byType"

　　 property name="name" value="钟健"/

　　 /bean

　　小结：

　　byname的时候，需要保证所有的bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！

　　bytype的时候，需要保证所有的bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！

　　6.4、使用注解实现自动装配

　　jdk1.5支持的注解，Spring2.5就支持注解了！

　　The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

　　要使用注解须知：

　　导入约束。context约束

　　配置注解支持： context:annotation-config/【重点】

 ?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

　　 https://www.springframework.org/schema/beans/spring-beans.xsd

　　 http://www.springframework.org/schema/context

　　 https://www.springframework.org/schema/context/spring-context.xsd"

　　 context:annotation-config/

　　 /beans

　　@Autowired

　　直接在属性上使用即可！也可以在set方式上使用！

　　使用Autowired 我们可以不用编写Set方法了，前提式你这个自动装配的属性在IOC（Spring）容器中存在，且符合名字byname！

　　科普：

@Nullable 字段标记了这个注解，说明了这个字段可以为null；

　　public People(@Nullable String name) {

　　this.name = name;

　　public @interface Autowired {

　　 boolean required() default true;

　　测试代码

public class People {

　　 //如果显示定义了Aurowired的required的属性为false，说明这个对象可以为null，否则不允许为空！

　　 @Autowired(required = false)

　　 private Cat cat;

　　 @Autowired

　　 private Dog dog;

　　 private String name;

　　如果 @Autowired 自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以谁用@Qualifier（value == "xxx")去配置@Autowired的使用，指定一个唯一的bean对象注入！

public class People {

　　
都是用来自动装配的，都可以放在属性字段上

　　@Autowired 通过 byType 的方式实现，而且必须要求这个对象存在！【常用】

　　@Resource 默认通过 byName的方式实现的，如果找不到名字，则通过byType实现！（名字属性）如果两个都找不到的情况下，就报错！【常用】

　　执行顺序不同： @Autowired 通过 byType 的方式实现。@Resource 通过 byName的方式实现的。

　　7、使用注解开发

　　在Spring4之后，要使用注解开发，必须要保证aop包的注入！

　　使用注解需要导入context约束，增加注解的支持！

 ?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

　　 https://www.springframework.org/schema/beans/spring-beans.xsd

　　 http://www.springframework.org/schema/context

　　 https://www.springframework.org/schema/context/spring-context.xsd"

　　 context:annotation-config/

　　 /beans

　　
衍生的注解

　　@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！

　　
controller 【@Controller】

　　这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean。

- @Autowired：自动装配，通过属性，名字

　　如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier（value == "xxx")

　　- @Nullable 字段标记了这个注解，说明了这个字段可以为null；

　　- @Resource：自动装配，通过名字，属性

　　
我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持

 !-- 指定要扫描的包，这个包下的注解就会生效 --

　　 context:component-scan base-package="com.jan.pojo"/

　　 context:annotation-config/

　　
我们现在要完全不适用Spring 的 xml 配置了，全权交给Java来做！

　　JavaConfig 是 Spring 的一个字项目，在 Spring 4之后，它成为了一个核心功能！

　　实体类

package com.jan.pojo;

　　
import org.springframework.beans.factory.annotation.Value;

　　import org.springframework.stereotype.Component;

　　//这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中

　　@Component

　　public class User {

　　 private String name;

　　 public String getName() {

　　 return name;

　　 @Value("ZHONGJIAN") //属性注入值

　　 public void setName(String name) {

　　 this.name = name;

　　 @Override

　　 public String toString() {

　　 return "User{" +

　　 "name=" + name + \ +

　　 };

　　配置文件

package com.jan.config;

　　import com.jan.pojo.User;

　　import org.springframework.context.annotation.Bean;

　　import org.springframework.context.annotation.ComponentScan;

　　import org.springframework.context.annotation.Configuration;

　　import org.springframework.context.annotation.Import;

　　//这个也是Spring容器托管，注册到容器中，因为它本来就是一个@Component

　　//@Configuration代表这是一个配置类，就和我们之前看到的beans.xml

　　@Configuration

　　@ComponentScan("com.jan.pojo")

　　@Import(JanConfig2.class)

　　public class JanConfig {

　　
//注册一个Bean，就相当于我们之前写的一个bean标签

　　 //这个方法的名字（eg：user），就相当于bean标签中的id属性

　　 //这个方法的返回值（eg：User），就相当于bean标签中的class属性

　　 @Bean

　　 public User user(){

　　 return new User(); // 就是返回要注入到bean的对象！

　　测试类

public class MyTest {

　　 public static void main(String[] args) {

　　
//如果完全使用了配置类的方式去做，我们就只能通过 AnnotationConfig 上下文来获取容器，通过配置类的class对象加载！

　　ApplicationContext context = new AnnotationConfigApplicationContext(JanConfig.class);

　　 User getUser = context.getBean("user", User.class);

　　 System.out.println(getUser.getName());

　　这种纯Java的配置方式，在SpringBoot中随处可见！

　　9、代理模式

　　为什么要学习代理模式？因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】

　　代理模式的分类：

　　9.1、静态代理

　　角色分析：

　　抽象角色：一般会使用接口或者抽象类来实现

　　真是角色：被代理的角色

　　代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作

　　客户：访问代理对象的人！

　　代码步骤：

　　
//代理角色，中介帮房租出租房子，但是呢？代理角色一般会有一些附属操作！

　　 Proxy proxy = new Proxy(host);

　　 //你不用面对房东，直接找中介租房子即可！

　　 proxy.rent();

　　代理模式的好处：

　　可以使真是角色的操作更加纯粹！不用去关注一些公共的业务

　　公共业务也就交给代理角色！实现了业务的分工！

　　公共业务发生扩展的时候，方便集中管理！

　　缺点：

　　一个真是角色就会产生一个代理角色；代码量会翻倍~开发效率会变低；

　　9.2、加深理解

　　对原来项目的基础上新增加一个方法，使用代理模式。若是在原代码上修改，万一出错，会造成不可估量的损失。

　　原项目：

　　
动态代理的代理类使动态生成的，不是我们为直接写好的！

　　动态代理分为两大类：基于接口的动态代理，基于的类的动态代理

　　基于接口----JDK动态代理【我们在这里使用】

　　基于类：cglib

　　java字节码：javasist

　　
需要了解两个类： Proxy ：代理； InvocationHandler：调用处理程序

　　动态代理的好处：

　　
//等我们会用这个类，自动生成代理类！

　　public class ProxyInvocationHandler implements InvocationHandler {

　　 //被代理的接口

　　 private Rent rent;

　　 public void setRent(Rent rent) {

　　 this.rent = rent;

　　 //生成得到代理类

　　 public Object getProxy(){

　　 return Proxy.newProxyInstance(this.getClass().getClassLoader(),

　　 rent.getClass().getInterfaces(),this );

　　
//处理代理实例，并返回结果

　　 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

　　 //动态代理的本质就是使用反射机制实现！

　　 seeHouse();

　　 Object result = method.invoke(rent, args);

　　 fare();

　　 return result;

　　 public void seeHouse(){

　　 System.out.println("中介带看房子");

　　 public void fare(){

　　 System.out.println("收中介费");

　　
pih.setRent(host);

　　 Rent proxy = (Rent) pih.getProxy();//这里的proxy就是动态生成的，我们并没有写！

　　 proxy.rent();

　　
实际动态代理的模板计较固定，可修改为通用的模板，然后再修改（target）

package com.jan.demo04;

　　import com.jan.demo03.Rent;

　　import java.lang.reflect.InvocationHandler;

　　import java.lang.reflect.Method;

　　import java.lang.reflect.Proxy;

　　//等我们会用这个类，自动生成代理类！

　　public class ProxyInvocationHandler implements InvocationHandler {

　　 //被代理的接口

　　 private Object target;

　　 public void setTarget(Object target) {

　　 this.target = target;

　　 //生成得到代理类

　　 public Object getProxy(){

　　 return Proxy.newProxyInstance(this.getClass().getClassLoader(),

　　 target.getClass().getInterfaces(),this );

　　
//处理代理实例，并返回结果:

　　 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

　　 //动态代理的本质就是使用反射机制实现！

　　 Object result = method.invoke(target, args);

　　 return result;

　　根据demo02的UserServiceImpl进行修改

　　
//等我们会用这个类，自动生成代理类！

　　public class ProxyInvocationHandler implements InvocationHandler {

　　 //被代理的接口

　　 private Object target;

　　 public void setTarget(Object target) {

　　 this.target = target;

　　 //生成得到代理类

　　 public Object getProxy(){

　　 return Proxy.newProxyInstance(this.getClass().getClassLoader(),

　　 target.getClass().getInterfaces(),this );

　　
//处理代理实例，并返回结果:

　　 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

　　 //动态代理的本质就是使用反射机制实现！

　　 log(method.getName());

　　 Object result = method.invoke(target, args);

　　 return result;

　　 public void log(String msg){

　　 System.out.println("执行了"+msg+"方法");

　　以上就是3、IOC创建对象的方法（ioc创建的对象是单例还是多例）的详细内容，想要了解更多 3、IOC创建对象的方法的内容，请持续关注盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

相关文章阅读