Spring5-IOC容器原理及管理

最新推荐文章于 2023-06-30 09:00:00 发布
最新推荐文章于 2023-06-30 09:00:00 发布
阅读量596 收藏 3
点赞数 1
分类专栏： Spring 文章标签： 开发语言 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45145809/article/details/123307944
版权

目录

1. IOC概念和原理

1.1 什么是IOC

（1）控制反转，把对象创建和对象之间的调用过程交给Spring进行管理
（2）使用IOC目的：降低耦合度
（3）入门案例就是IOC实现

1.2 IOC底层原理

XML解析，工厂模式，反射
在这里插入图片描述

1.3 IOC BeanFactory接口

（1）IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
（2）Spring提供IOC容器两种实现方式（两个接口）
	1）BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用。加载配置文件时候不会创建对象，在使用对象时才会去创建对象
	2）ApplicationContext：BeanFactory接口的子接口，功能更强大，一般由开发人员使用。加载配置文件时候就会把配置文件对象进行创建（推荐，耗时操作一般在容器启动完成）
（3）ApplicationContext接口有实现类

在这里插入图片描述

2. IOC操作Bea管理

（1）什么是Bean管理
	Bean管理指的是两个操作：Spring创建对象和Spring注入属性
（2）Bean管理操作有两种方式
	1）基于xml配置文件方式实现
	2）基于注解方式实现

3. IOC操作Bean管理（基于xml方式）

3.1 基于xml方式创建对象

<bean id="user" class="com.wqd.spring5.User"></bean>

1）在spring配置文件中，使用bean标签，标签里面添加对应属性就可以实现对象创建
2）在bean标签中有很多属性，介绍常用属性
	id：唯一标识
	class：类全路径名
3）创建对象时候，默认也是执行无参构造方法完成对象创建

3.2 基于xml注入属性

DI：依赖注入，就是注入属性

3.2.1 使用set方法进行注入

①创建类，定义属性和set方法

public class Book {
    //创建属性
    private String bookName;
    private String bookAuthor;
    //创建属性对应的set方法

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    public void setBookAuthor(String bookAuthor) {
        this.bookAuthor = bookAuthor;
    }

    public void testPrint(){
        System.out.println(bookName+":"+bookAuthor);
    }
}

②在spring配置文件配置对象创建，配置属性注入

<!-- Set方法注入属性   -->
    <bean id="book" class="com.wqd.spring5.Book">
    <!-- 使用property完成属性注入
        name：类里面属性名称
        value：向属性注入的值
        -->
        <property name="bookName" value="三体"></property>
        <property name="bookAuthor" value="刘慈欣"></property>
    </bean>

③测试

//测试Set方法注入属性
    @Test
    public void testbook(){
        //1.加载配置文件

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        //2.获取配置创建的对象
        Book book = context.getBean("book", Book.class);

        System.out.println(book);
        book.testPrint();

    }

在这里插入图片描述

3.2.2 使用有参构造注入

①创建类，定义属性，创建属性对应哟惨构造方法

public class Orders {
    //属性
    private String oname;
    private String address;

    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }

    public void OrdersPrint(){
        System.out.println(oname+":"+address);
    }
}

②在spring配置文件中进行配置

<!-- 有参构造 注入属性   -->
    <bean id="orders" class="com.wqd.spring5.Orders">
        <constructor-arg name="oname" value="电脑"></constructor-arg>
        <constructor-arg name="address" value="中国"></constructor-arg>
    </bean>

③测试

//测试有参构造注入属性
    @Test
    public void testOrders(){
        //1.加载配置文件

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        //2.获取配置创建的对象
        Orders orders = context.getBean("orders", Orders.class);

        System.out.println(orders);
        orders.OrdersPrint();

    }

在这里插入图片描述

3.2.3 p名称空间注入

使用p命名空间注入，可以简化xml配置方式
①添加p名称空间在配置文件中
在这里插入图片描述
②进行属性注入，在bean标签里面进行操作

<bean id="book" class="com.wqd.spring5.Book" p:bookName="西游记" p:bookAuthor="吴承恩">		</bean>

③测试
在这里插入图片描述

3.3 IOC注入其它类型属性

3.3.1 字面量

（1）null值

往book类添加address字段

<!-- Set方法注入属性   -->
    <bean id="book" class="com.wqd.spring5.Book">
        <property name="bookName" value="三体"></property>
        <property name="bookAuthor" value="刘慈欣"></property>
        <property name="address">
            <null></null>
        </property>
    </bean>

在这里插入图片描述

（2）属性值包含特殊符号
<property name="address">
       <value><![CDATA[<<<北京>>>]]></value>
</property>

3.3.2 注入属性-外部bean

创建两个类service类和dao类
在service中调用dao里的方法
在spring配置文件中进行配置

public interface UserDao {

    public void update();
}

public class UserDaoImpl implements UserDao{
    @Override
    public void update() {
        System.out.println("userDao update。。。。。。");
    }
}

public class UserService {

    //创建UserDao属性，生成set方法
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("service add........");
        userDao.update();
    }
}

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="userService" class="com.wqd.spring5.service.UserService">
        <!-- 注入userDao对象
           name属性：类里面属性名称
           ref属性：创建userDao对象bean标签ID值-->
        <property name="userDao" ref="userDaoImpl"></property>

    </bean>
    <bean id="userDaoImpl" class="com.wqd.spring5.dao.UserDaoImpl"></bean>

</beans>

public class TestBean {
    //测试Set方法注入属性
    @Test
    public void testbook(){
        //1.加载配置文件

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");

        //2.获取配置创建的对象
        UserService userService = context.getBean("userService", UserService.class);

        System.out.println(userService);
        userService.add();

    }
}

在这里插入图片描述

3.3.3 注入属性-内部bean

一对多关系：部门和员工
在实体类之间表示一对多关系，员工所属部门，使用对象类型属性进行表示

public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

public class Emp {

    private String ename;
    private String gender;
    //员工属于某一个部门，使用对象形式表示
    private Dept dept;

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "ename='" + ename + '\'' +
                ", gender='" + gender + '\'' +
                ", dept=" + dept +
                '}';
    }
}

<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--内部bean    -->
    <bean id="emp" class="com.wqd.spring5.bean.Emp">
        <property name="ename" value="zhangsan"></property>
        <property name="gender" value="男"></property>
        <!--设置对象类型属性-->
        <property name="dept">
            <bean id="dept" class="com.wqd.spring5.bean.Dept">
                <property name="dname" value="技术部"></property>
            </bean>
        </property>
    </bean>

</beans>

//测试内部bean
    @Test
    public void testbean(){
        //1.加载配置文件

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");

        //2.获取配置创建的对象
        Emp emp = context.getBean("emp", Emp.class);

        System.out.println(emp);

    }

3.3.4 注入属性-级联赋值

第一种写法
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--内部bean    -->
    <bean id="emp" class="com.wqd.spring5.bean.Emp">
        <property name="ename" value="zhangsan"></property>
        <property name="gender" value="男"></property>
        <!--级联赋值-->
        <property name="dept" ref="dept"></property>
        
    </bean>
    <bean id="dept" class="com.wqd.spring5.bean.Dept">
        <property name="dname" value="技术部####"></property>
    </bean>

</beans>

在这里插入图片描述

第二种写法

必须在emp中生成dept的get方法

public Dept getDept() {
        return dept;
    }

<!--内部bean    -->
    <bean id="emp" class="com.wqd.spring5.bean.Emp">
        <property name="ename" value="zhangsan"></property>
        <property name="gender" value="男"></property>
        <!--级联赋值-->
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="研发"></property>
    </bean>
    <bean id="dept" class="com.wqd.spring5.bean.Dept">
        <property name="dname" value="技术部####"></property>
    </bean>

在这里插入图片描述

3.3.5 xml注入集合属性

注入数组，list，map和set

public class Stu {
    //1.数组类型
    private String[] course;
    //2.list集合类型属性
    private List<String> list;
    //3.map集合类型属性
    private Map<String,String> maps;
    //4.set集合类型属性
    private Set<String> sets;

    public void setCourse(String[] course) {
        this.course = course;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void test(){
        System.out.println(Arrays.toString(course));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
    }
}

<?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="stu" class="com.wqd.spring5.Stu">
<!--        数组类型属性注入-->
        <property name="course">
            <array>
                <value>java课程</value>
                <value>数据库课程</value>
            </array>
        </property>
<!--        list类型属性注入-->
        <property name="list">
            <list>
                <value>小王</value>
                <value>小李</value>
            </list>
        </property>
<!--        map类型属性注入-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="GO" value="go"></entry>
            </map>
        </property>
<!--        set类型属性-->
        <property name="sets">
            <set>
                <value>MySQL</value>
                <value>Redis</value>
            </set>
        </property>
    </bean>
 </beans>

@Test
    public void test1(){
        //1.加载配置文件

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        //2.获取配置创建的对象
        Stu stu = context.getBean("stu", Stu.class);

        System.out.println(stu);
        stu.test();
    }

在这里插入图片描述

3.3.6 在集合里面设置对象类型指

创建Course类

public class Course {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Course{" +
                "name='" + name + '\'' +
                '}';
    }
}

Stu类中加入courseList

public class Stu {
    //1.数组类型
    private String[] course;
    //2.list集合类型属性
    private List<String> list;
    //3.map集合类型属性
    private Map<String,String> maps;
    //4.set集合类型属性
    private Set<String> sets;

    //5.集合里面设置对象
    private List<Course> courseList;

    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }

    public void setCourse(String[] course) {
        this.course = course;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void test(){
        System.out.println(Arrays.toString(course));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
        System.out.println(courseList);
    }
}

<?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="stu" class="com.wqd.spring5.Stu">
<!--        数组类型属性注入-->
        <property name="course">
            <array>
                <value>java课程</value>
                <value>数据库课程</value>
            </array>
        </property>
<!--        list类型属性注入-->
        <property name="list">
            <list>
                <value>小王</value>
                <value>小李</value>
            </list>
        </property>
<!--        map类型属性注入-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="GO" value="go"></entry>
            </map>
        </property>
<!--        set类型属性-->
        <property name="sets">
            <set>
                <value>MySQL</value>
                <value>Redis</value>
            </set>
        </property>
        <!--    注入list集合类型，值是对象-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
<!--创建多个course对象-->
    <bean id="course1" class="com.wqd.spring5.Course">
        <property name="name" value="Spring"></property>
    </bean>
    <bean id="course2" class="com.wqd.spring5.Course">
        <property name="name" value="MyBatis"></property>
    </bean>
</beans>

在这里插入图片描述

3.3.7 把集合注入部分提取出来

在spring配置文件中引入名称空间util
使用util标签完成list集合注入

public class Book {
    private List<String> name;

    public void setName(List<String> name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name=" + name +
                '}';
    }
}

<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
<!--使用util标签完成list集合注入提取-->
    <util:list id="bookList">
        <value>三体</value>
        <value>五体</value>
    </util:list>
<!--提取list集合类型属性注入使用-->
    <bean id="book" class="com.wqd.spring5.Book">
        <property name="name" ref="bookList"></property>
    </bean>
</beans>

在这里插入图片描述

3.4 IOC操作Bean管理（FactoryBean）

1）Spring中有两种类型bean，一种普通bean，另一种工厂bean（FactoryBean）
2）普通bean：在配置文件中定义bean类型就是返回值类型
3）工厂bean：在配置文件定义bean类型可以和返回类型不一样
  ○ 第一步：创建类，让这个类作为工厂bean，实现接口factoryBean
  ○ 第二步：实现接口里的方法，在实现的方法中定义返回的bean类型

public class MyBean implements FactoryBean {
//    定义返回的bean
    @Override
    public Course getObject() throws Exception {
        Course course=new Course();
        course.setName("java");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

<?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="myBean" class="com.wqd.spring5.factory.MyBean"></bean>
</beans>

@Test
    public void test3(){
        //1.加载配置文件

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");

        //2.获取配置创建的对象
        Course course = context.getBean("myBean", Course.class);

        System.out.println(course);

    }

在这里插入图片描述

3.5 IOC操作Bean管理（bean作用域）

1）在spring中可以设置bean实例时单实例还是多实例
2）在spring里面，默认情况下，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"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
<!--使用util标签完成list集合注入提取-->
    <util:list id="bookList">
        <value>三体</value>
        <value>五体</value>
    </util:list>
<!--提取list集合类型属性注入使用-->
    <bean id="book" class="com.wqd.spring5.Book">
        <property name="name" ref="bookList"></property>
    </bean>
</beans>

@Test
    public void test2(){
        //1.加载配置文件

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");

        //2.获取配置创建的对象
        Book book1 = context.getBean("book", Book.class);
        Book book2 = context.getBean("book", Book.class);
        System.out.println(book1);
        System.out.println(book2);
    }

在这里插入图片描述
3）如何设置单实例还是多实例

在spring配置文件bean标签里面有属性（scope）用于设置单实例还是多实例 		
scope属性值
	第一个值：默认值，singleton，表示是单实例对象
	第二个值：prototype，表示是多例对象

 <bean id="book" class="com.wqd.spring5.Book" scope="prototype">
        <property name="name" ref="bookList"></property>
    </bean>

在这里插入图片描述

● singleton和prototype区别
	 ○ singleton单实例，prototype多实例
	 ○ 设置scope值是singleton时候，加载spring配置文件就会创建单实例对象
	 ○ 设置scope值是prototype时，不在加载spring配置文件时创建对象，在调用getBean方法时创建多实例对象

3.6 bean声明周期

（1）声明周期
	从对象创建到对象销毁的过程
（2）bean声明周期
	1）通过构造函数创建bean实例（无参构造）
	2）为bean的属性设置值和对其他bean引用（调用set方法）
	3）调用bean的初始化方法（需要进行配置配置初始化的方法）
	4）bean可以使用了（对象获取到了）
	5）当容器关闭时，调用bean的销毁的方法（需要进行配置销毁的方法）

public class Order {

    //无参构造
    public Order(){
        System.out.println("第一步 执行无参构造创建bean实例");
    }
    private String name;

    public void setName(String name) {
        this.name = name;
        System.out.println("第二部 调用set方法设置属性值");
    }

    //创建执行的初始化的方法
    public void initMethod(){
        System.out.println("第三步 执行初始化的方法");
    }

    //创建执行的销毁方法
    public void destroyMethod(){
        System.out.println("第五步 执行销毁的方法");
    }
}

<?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="orders" class="com.wqd.spring5.bean.Order" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="手机"></property>
    </bean>
</beans>

@Test
    public void test4(){
        //1.加载配置文件

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");

        //2.获取配置创建的对象
        Order order = context.getBean("orders", Order.class);
        System.out.println("第四步 获取创建bean实例对象");
        System.out.println(order);
        //手动销毁
        context.close();

    }

在这里插入图片描述

3.7 bean的后置处理器

bean的声明周期有7步
	1）通过构造函数创建bean实例（无参构造）
	2）为bean的属性设置值和对其他bean引用（调用set方法）
	3）把bean实例传递bean后置处理器的方法postProcessBeforeInitialization
	4）调用bean的初始化方法（需要进行配置配置初始化的方法）
	5）把bean实例传递bean后置处理器的方法postProcessAfterInitialization
	6）bean可以使用了（对象获取到了）
	7）当容器关闭时，调用bean的销毁的方法（需要进行配置销毁的方法）

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第3步 在初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第5步 在初始化之后执行的方法");
        return bean;
    }
}

public class Order {

    //无参构造
    public Order(){
        System.out.println("第1步 执行无参构造创建bean实例");
    }
    private String name;

    public void setName(String name) {
        this.name = name;
        System.out.println("第2步 调用set方法设置属性值");
    }

    //创建执行的初始化的方法
    public void initMethod(){
        System.out.println("第4步 执行初始化的方法");
    }

    //创建执行的销毁方法
    public void destroyMethod(){
        System.out.println("第7步 执行销毁的方法");
    }
}

<?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="orders" class="com.wqd.spring5.bean.Order" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="手机"></property>
    </bean>
<!--    配置后置处理器-->
    <bean id="myBeanPost" class="com.wqd.spring5.bean.MyBeanPost"></bean>
</beans>

@Test
    public void test4(){
        //1.加载配置文件

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");

        //2.获取配置创建的对象
        Order order = context.getBean("orders", Order.class);
        System.out.println("第6步 获取创建bean实例对象");
        System.out.println(order);
        //手动销毁
        context.close();
    }

在这里插入图片描述

3.8 xml自动装配

（1）什么是自动装配
根据指定装配规则（属性名称或者属性类型），spring自动将匹配的属性值进行注入
（2）演示过程

public class Dept {
    @Override
    public String toString() {
        return "Dept{}";
    }
}

public class Emp {
    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "dept=" + dept +
                '}';
    }
}

<!--实现自动装配
    bean标签属性autowire
        byName:根据属性名称注入，注入值bean的id值和类属性名称一样
        byType:根据属性类型注入-->
        <bean id="emp" class="com.wqd.spring5.autowire.Emp" autowire="byName">
<!--            <property name="dept" ref="dept"></property>-->
        </bean>
        <bean id="dept" class="com.wqd.spring5.autowire.Dept"></bean>

@Test
    public void test5(){
        //1.加载配置文件

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");

        //2.获取配置创建的对象
        Emp emp = context.getBean("emp", Emp.class);

        System.out.println(emp);

    }

在这里插入图片描述

3.9 外部属性文件

（1）直接配置数据库信息
导入druid jar包

<!--直接配置连接池--> 
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
                <property name="driverClassName" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql:///user_db" />
                <property name="username" value="root" />
                <property name="password" value="root" />
</bean>

（2）引入外部属性文件
1）创建jdbc.properties文件

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql:///user_db
prop.userName=root
prop.password=root

2）引入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 http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

<!--        引入外部属性文件-->
        <context:property-placeholder location="classpath:jdbc.properties"/>
<!--        配置连接池-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
                <property name="driverClassName" value="${prop.driverClass}"></property>
                <property name="url" value="${prop.url}"></property>
                <property name="username" value="${prop.userName}"></property>
                <property name="password" value="${prop.password}"></property>
        </bean>

</beans>

3.10 基于注解方式

(1）什么是注解
	1）注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值。。。。）
	2）使用注解，注解作用在类上面，方法上面，属性上面
	3）使用注解的目的：简化XML配置
(2）Spring针对Bean管理中创建对象提供注解
	1）@Component
	2）@Service
	3）@Controller
	4）@Repository
这四个注解功能是一样的，都可以用来创建bean实例
(3）基于注解方式创建对象
先引入依赖 spring-aop-5.2.6.RELEASE.jar
开启组件扫描

<?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 http://www.springframework.org/schema/context/spring-context.xsd">

<!--        开启组件扫描
            如果扫描多个包，多个包用逗号隔开或扫描包上层目录-->
    <context:component-scan base-package="com.wqd.spring5"></context:component-scan>

</beans>

创建类

@Service(value = "userService")//value可以默认不写，默认值为首字母小写的类名称
public class UserService {
    public void add(){
        System.out.println("service add...");
    }
}

测试

@Test
    public void test1(){
        //1.加载配置文件

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        //2.获取配置创建的对象
        UserService userService = context.getBean("userService", UserService.class);

        System.out.println(userService);
        userService.add();
    }

在这里插入图片描述

3.11 开启组件扫描细节配置

<!--示例 1
 use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
 context:include-filter ，设置扫描哪些内容
--><context:component-scan base-package="com.wqd" use-defaultfilters="false">
 <context:include-filter type="annotation" 
 
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--示例 2
 下面配置扫描包所有内容
 context:exclude-filter： 设置哪些内容不进行扫描
--><context:component-scan base-package="com.wqd">
 <context:exclude-filter type="annotation" 
 
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

3.12 基于注解方式实现属性注入

（1）@Autowired：根据属性类型进行自动装配
	1）在service和dao添加创建对象注解
	2）在属性上使用注解

public interface UserDao {

    public void add();
}

@Service(value = "userDaoImpl")
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("UserDao add.....");
    }
}

@Service(value = "userService")//value可以默认不写，默认值为首字母小写的类名称
public class UserService {

    //添加注入属性注解，不需要添加set方法
    @Autowired
    private UserDao userDao;

    public void add(){
        System.out.println("service add...");
        userDao.add();
    }
}

public class testdemo1 {

    @Test
    public void test1(){
        //1.加载配置文件

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

        //2.获取配置创建的对象
        UserService userService = context.getBean("userService", UserService.class);

        System.out.println(userService);
        userService.add();
    }

}

在这里插入图片描述
（2）@Qualifier：根据名称进行注入，使用时必须和@Autowired一起使用
如果UserDao有多个实现类，可以再根据名称注入

@Service(value = "userService")//value可以默认不写，默认值为首字母小写的类名称
public class UserService {

    //添加注入属性注解，不需要添加set方法
    @Autowired
    @Qualifier(value = "userDaoImpl")
    private UserDao userDao;

    public void add(){
        System.out.println("service add...");
        userDao.add();
    }
}

（3）@Resource：可以根据类型注入，也可以根据名称注入

@Service(value = "userService")//value可以默认不写，默认值为首字母小写的类名称
public class UserService {

    //添加注入属性注解，不需要添加set方法
    //@Autowired
    //@Qualifier(value = "userDaoImpl")
    //@Resource
    @Resource(name = "userDaoImpl")
    private UserDao userDao;

    public void add(){
        System.out.println("service add...");
        userDao.add();
    }
}

@Resource：import javax.annotation.Resource; 是javax包
其它两个都是spring包
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
推荐使用spring包

（4）@Value：注入普通类型属性

@Service(value = "userService")//value可以默认不写，默认值为首字母小写的类名称
public class UserService {

    //添加注入属性注解，不需要添加set方法
    @Autowired
    //@Qualifier(value = "userDaoImpl")
    //@Resource
    //@Resource(name = "userDaoImpl")
    private UserDao userDao;

    @Value("abc123")
    private String name;

    public void add(){
        System.out.println("service add..."+name);
        userDao.add();
    }
}

在这里插入图片描述

3.13 纯注解开发

（1）创建配置类，替代xml配置文件

@Configuration //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.wqd"})
public class SpringConfig {
}

（2）测试类

@Test
    public void test2(){
        
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        
        UserService userService = context.getBean("userService", UserService.class);

        System.out.println(userService);
        userService.add();
    }

在这里插入图片描述

自律成就自由
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
IOC如何管理对象之间的依赖关系
故小曲啊
07-06 716
IOC容器不是人类，无法像酒吧服务生一样通过大脑记忆对象之间的依赖关系。因而，它需要寻求其他方式记录对象的依赖关系 主流的IOC容器使用的注册对象管理信息方式有以下几种： 直接编码 配置文件方式 元数据方式 对于直接编码的方式 核心思路是： 为相应的类指定对应的具体实例，告知Ioc容器，当我们需要这种类型对象实例，把容器中注册的对应的具体实例返回。 其下是一段伪代码： IoContaine...
SpringIOC对象管理
Super小龙的博客
03-30 3405
概念 IOC（Inversion of Control）：控制反转。 IOC是Spring框架中的一个核心功能，即由SpringIOC容器来管理组件对象的生命周期，负责组件对象的创建和组件对象之间的依赖关系，这样可以大大降低程序各组件之间的耦合关系，符合软件工程中低耦合高内聚的理念。 环境搭建 搭建Spring环境就行，利用开发工具很容易，如果手动建立工程文件就需要下载相应的spring核...
SpringIOC机制详解
互联网底层民工的博客
06-30 5473
所谓Bean的作用域其实就是指Spring给我们创建出的对象的存活范围，在配置文件中通过bean的scope属性指定取值范围说明singleton默认值，单例的prototype多例的requestWEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中sessionWEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中。
Spring-IOC容器进行对象管理
如何心安理得的在老板眼皮下摸鱼
04-05 2186
目录 IOC概念 IOC思想 Spring管理对象 集成依赖 spring的配置文件（Applicationcontext.xml） 创建实体类User Spring对Bean的实例化方式 基于配置形式 1.通过无参构造函数实例化 2.通过静态工厂方式实例化 3.通过普通工厂方式实例化Bean 基于注解形式 Spring中依赖注入方式 基于xml配置实现依赖注入 1.有参构造函数 2.setter方式注入 基于注解形式注入依赖 IOC概念 IOC(Inversion O
Spring IoC容器管理Action
weixin_30729609的博客
09-25 341
Spring IoC容器管理Action有两种方式：DelegatingRequestProcessor、DelegatingActionProxy 不管采用哪一种方式，都需要随应用启动时创建ApplicationContext实例，由Struts负责在应用启动时创建ApplicationContext实例。Struts中提供了PlugIn的扩展点，可在应用启动和关闭时，创建或销毁某些资源。 ...
Java-Spring-SpringIoC容器-SpringIoC的学习
最新发布
10-11
在Java Spring框架中，Spring IoC（Inversion of Control，控制反转）是核心特性之一，它使得应用程序的组件之间的依赖关系不再由代码直接管理，而是交由Spring IoC容器负责。这种设计模式降低了代码间的耦合，提高...
Spring核心容器IOC原理实例解析
08-25
Spring核心容器是IOC容器的核心组件，负责管理Bean对象及其相互依赖关系。在Spring框架中，IOC容器是通过BeanFactory接口来定义的，这个接口提供了许多方法来管理Bean对象，例如获取Bean实例、判断Bean是否存在、...
Spring实现一个简单的SpringIOC容器
08-30
Spring的IOC（Inversion of Control，控制反转）容器是其核心...虽然这个简单的实现可能没有Spring框架那样全面和高效，但它可以帮助我们理解Spring IOC容器的工作原理，为进一步学习和研究Spring框架打下坚实的基础。
浅谈Spring IoC容器的依赖注入原理
08-27
浅谈Spring IoC容器的依赖注入原理 Spring IoC容器的依赖注入原理是Spring框架的核心机制之一，负责将服务对象（Bean）实例化并将其提供给客户端使用。依赖注入原理可以分为两个阶段：IoC容器初始化和Bean实例化。 ...
Spring IOC和DI实现原理及实例解析
08-19
Spring IOC和DI实现原理及实例解析 Spring IOC（Inversion ...Spring IOC和DI的实现原理及实例解析是Spring框架的基础，它提供了一种灵活和可扩展的方式来管理对象之间的依赖关系，提高了应用程序的可维护性和灵活性。
Spring中的Bean管理
weixin_52674481的博客
05-26 485
了解Bean的配置以及，以及bean元素的常用属性以及子属性了解Bean实例化的三种方法使用构造方法进行Bean的实例化创建工厂类，定义静态工厂方法，bean配置指向静态工厂类和静态工厂方法创建工厂的Bean实例，在bean配置中在用相应属性指向工厂的Bean以及实例工厂方法了解Bean的作用域了解Bean的装配方式基于XML装配：也就是setter方法注入以及构造方法注入。
浅谈 IOC 什么是 IOC？
热门推荐
平凡的人类的博客
05-27 3万+
本文以文字为主题，并没有代码案例，仅限于记录自己对于 IOC 的理解，文中也啥特别高深的东西，大牛和大佬可以忽略本文，以免浪费您宝贵的时间 什么是 IOC ？ IOC （Inversion Of Control，控制倒转），是spring的核心，贯穿始终，所谓IOC ，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。所有的类都会在spring容器中...
Spring-IoC对象管理
卓尔游侠
05-31 874
1.spring        spring是J2EE应用程序框架，是轻量级的IoC和AOP的容器框架，主要是针对javaBean的生命周期进行管理的轻量级容器 2.主动查找和依赖注入      2.1主动查找：new的方式由我们的应用程序负责服务（对象）定位查找。而且依赖都写在代码中，如果修改的话比较麻烦。                                工厂：工厂配置好之
IOC容器，IOC操作bean管理
weixin_62414347的博客
08-07 300
什么是IOC:，IOC Bean管理操作bean标签的常用属性：属性值的两种方式，级联赋值bean的作用域，bean 的生命周期 ，IOC操作bean管理（基于注解方式），bean的后置处理，器外部属性文件
Spring IOC原理，Spring容器，IOC容器以及Spring中的DI
m0_52410507的博客
05-15 277
文章目录一、Spring IOC原理1.IOC定义2.IOC能做什么3.Spring容器管理对象1.添加Spring核心组件2.Spring配置文件3.创建实体类（xxx.java）4.IOC容器管理对象4.IOC容器1、 BeanFactory2、 ApplicationContext的常用实现类3、 容器管理对象4、 Spring中Bean的实例1.基于XML的配置方式转配Bean2.基于注解方式装配Bean（自动装配）3.通过java代码装配Bean（组件扫描）二、Spring中DI1、基于XML配置
浅谈Spring IOC容器
OceanSky的专栏
01-29 570
Spring容器负责对象的创建、装配、销毁的整个生命周期管理；关于Spring容器我们最常听闻的一个术语就是IOC容器，所谓的IOC，是一种叫做控制反转的思想；通俗的来说，我在应用程序之中就不在过问对象的创建和管理对象之间的依赖关系了，都让IOC容器帮我代劳了，也就是说，我把对象创建、管理的控制权都交给Spring容器，这是一种控制权的反转，所以Spring容器才能被称为IOC容器。不过我们也要清...
Spring IOC容器
qq_58309003的博客
11-14 1147
什么是IOC IOC – Inverse of Control，控制反转，将对象的创建权力反转给Spring框架！ 在java当中一个类想要使用另一个类的方法，就必须在这个类当中创建这个类的对象，那么可能会出现如下情况， 比如A类当中创建着B对象，B类当中有C对象，C类当中有A对象，这个如果一个类出了问题，那么可能会导致这个框架出现问题。 Spring 将创建对象的权利给了IOC，在IOC当中创建了ABC三个对象吗，那么我们我们其他的类只需要调用集合， 大大的解决了程序耦合性的问题。 控制反转（Inve.
【Spring源码学习】spring IOC容器管理
wufaqidong1的博客
07-22 239
具体源码下载参考我的资源B站【尚硅谷】Spring框架视频教程_spring5源码资料下载。2、idea新建项目先实现一个IOC例子。
入门IOC解析
m0_46405589的博客
08-13 236
前天总结了一下Spring框架中AOP的原理和作用，今天来总结一下另一核心—>IOC（控制反转） 废话不多说，直接进入正题 IOC（概念和原理） 1、什么是 IOC？ （1）控制反转，把对象创建和对象之间的调用过程，交给Spring 进行管理。 （2）使用 IOC 目的：为了代码耦合度降低 2、IOC 底层原理 xml 解析、工厂模式、反射 IOC（BeanFactory 接口） 1、IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂 2、Spring 提供 IOC 容器实现两种方式：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值