Spring5 框架【二】 IOC容器

最新推荐文章于 2024-07-18 09:20:47 发布

geyiwei-suzhou

最新推荐文章于 2024-07-18 09:20:47 发布

阅读量127

点赞数

分类专栏： Spring5 文章标签： java java8 spring spring 5 ioc

本文链接：https://blog.csdn.net/REX1129/article/details/113541072

版权

Spring5 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

视频链接：Spring5框架最新版教程
文章源码：https://github.com/geyiwei-suzhou/spring5/

IOC底层原理

什么是IOC？

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

IOC底层原理

（1）xml解析、工厂模式、反射

（2）图解IOC底层原理

原始方式
工厂模式：降低耦合度
IOC过程：进一步降低耦合度

IOC接口（BeanFactory）

IOC容器

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

Spring提供IOC容器实现两种方式：（两个接口）

BeanFactory

IOC容器基本实现，是Spring内部的使用接口，不提倡开发人员进行使用

* 加载配置文件时，不会创建对象，在获取对象（使用）才会创建对象

ApplicationContext

BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用

*加载配置文件时就会把在配置文件中配置的对象进行创建

Ctrl + H 打开ApplicationContext实现，发现有两个实现类
ApplicationContext实现类
FileSystemXmlApplicationContext：读取配置文件在系统盘上的路径
ClassPathXmlApplicationContext：读取配置文件在src目录下的路径

Bean管理指的是两个操作

（1）Spring创建对象
（2）Spring注入属性

Bean管理操作的两种方式

（1）基于xml配置文件方式实现
（2）基于注解方式实现

IOC操作Bean管理（基于xml）

（1）基于xml方式创建对象

在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
在bean标签中有很多属性，介绍常用属性

id：唯一表示
class：类全路径（包类路径）
name：类似id，可以加特殊符号（弃用）

创建对象的时候，默认执行无参构造函数完成对象创建

（2）基于xml方式注入属性

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

第一种注入方法：使用set方法进行注入
（1）创建类，定义属性和对应的set方法

package com.antherd.spring5;

/**
 * 演示使用set方法进行注入属性
 */
public class Book {

  // 创建属性
  private String bname;
  private String bauther;

  // 创建属性对应的set方法
  public void setBname(String bname) {
    this.bname = bname;
  }

  public void setBauther(String bauther) {
    this.bauther = bauther;
  }
  public void testDemo() {
    System.out.println(bname + "::" + bauther);
  }
}

（2）在spring配置文件中配置对象创建，配置属性注入

<!-- 2 set方法注入属性 -->
<bean id="book" class="com.antherd.spring5.Book">
  <!-- 使用property完成属性注入
        name：类里面属性名称
        value：向属性注入的值
   -->
  <property name="bname" value="易筋经"></property>
  <property name="bauther" value="达摩老祖"></property>
</bean>

测试代码：

@Test
public void testBook1() {

  // 1.加载spring配置文件
  ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
  // 2.获取配置创建的对象
  Book book = context.getBean("book", Book.class);

  System.out.println(book);
  book.testDemo();
}

第二种注入方法：使用有参数构造进行注入
（1）创建类，定义属性和构造方法

package com.antherd.spring5;

/**
 * 使用有参数构造进行注入属性
 */
public class Orders {

  private String oname;
  private String address;

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

（2）在spring配置文件中配置对象创建，配置构造器注入

<!-- 3 有参数构造注入属性 -->
  <bean id="order" class="com.antherd.spring5.Orders">
    <constructor-arg name="oname" value="电脑"></constructor-arg>
    <constructor-arg name="address" value="China"></constructor-arg>
  </bean>

测试代码：

@Test
public void testOrders() {
  // 1.加载spring配置文件
  ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
  // 2.获取配置创建的对象
  Orders orders = context.getBean("orders", Orders.class);

  System.out.println(orders);
  orders.ordersTest();
}

第三种p名称空间注入（set方法的简化）
（1）添加一个p名称空间在配置文件中

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

（2）进行属性注入，在bean标签里面进行操作

 <!-- 4 bean标签内属性注入 -->
 <bean id="book" class="com.antherd.spring5.Book" p:bname="九阳神功" p:bauther="无名氏">
 </bean>

第四种注入其他类型属性

字面量（属性设置固定值）

（1）null值

<property name="address">
  <null></null>
</property>

（2）属性值包含特殊符号

<!-- 属性值包含特殊符号 value="<<南京>>"
  1 把<>进行转义 lt; gt;
  2 把带特殊符号内容写到CDATA
-->
<property name="address">
  <value><![CDATA[<<南京>>]]></value>
</property>

注入属性

（1）外部bean

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

package com.antherd.spring5.dao;

public interface UserDao {
  void update();
}

package com.antherd.spring5.dao;

public class UserDaoImpl implements UserDao{

  @Override
  public void update() {
    System.out.println("dao update................");
  }
}

package com.antherd.spring5.service;

import com.antherd.spring5.dao.UserDao;
import com.antherd.spring5.dao.UserDaoImpl;

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对象
    // UserDao userDao = new UserDaoImpl();
    userDao.update();
  }
}

创建bean2.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 http://www.springframework.org/schema/beans/spring-beans.xsd">

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

</beans>

创建测试类：

package com.antherd.spring5.testDemo;

import com.antherd.spring5.Orders;
import com.antherd.spring5.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestBean {

  @Test
  public void testAdd() {

    // 1.加载spring配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
    // 2.获取配置创建的对象
    UserService userService = context.getBean("userService", UserService.class);

    userService.add();
  }
}

（2）内部bean
一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门；部门是一，员工是多
在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示

package com.antherd.spring5.bean;

/**
 * 部门类
 */
public class Dept {

  private String dname;

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

package com.antherd.spring5.bean;

/**
 * 员工类
 */
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;
  }
  
   public void add() {
    System.out.println(ename + "::" + gender + "::" + dept);
  }
}

在spring配置文件bean3.xml中进行配置

<!-- 内部bean -->
<bean id="emp" class="com.antherd.spring5.bean.Emp">
  <!-- 先设置两个普通的属性 -->
  <property name="ename" value="lucy"></property>
  <property name="gender" value="女"></property>
  <!-- 对象类型的属性 -->
  <property name="dept">
    <bean id="dept" class="com.antherd.spring5.bean.Dept">
      <property name="dname" value="安保部"></property>
    </bean>
  </property>
</bean>

测试

@Test
public void testBean2() {

  // 1.加载spring配置文件
  ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
  // 2.获取配置创建的对象
  Emp emp = context.getBean("emp", Emp.class);

  emp.add();
}

（3）级联赋值
第一种写法：

<!-- 级联赋值 -->
<bean id="emp" class="com.antherd.spring5.bean.Emp">
  <!-- 先设置两个普通的属性 -->
  <property name="ename" value="lucy"></property>
  <property name="gender" value="女"></property>
  <!-- 级联赋值 -->
  <property name="dept" ref="dept">
  </property>
</bean>
<bean id="dept" class="com.antherd.spring5.bean.Dept">
  <property name="dname" value="财务部"></property>
</bean>

第二种写法

<!-- 级联赋值 需要在Emp生成getDept方法-->
    <property name="dept" ref="dept"></property>
    <property name="dept.dname" value="技术部"></property>

（4）注入集合属性
注入数组类型属性
注入List集合类型属性
注入Map集合类型属性

新建Stu类：

package com.antherd.spring5.collectiontype;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class Stu {

  // 1 数组类型的属性
  private String[] courses;

  // 2 list集合类型属性
  private List<String> list;

  // 3 map集合类型属性
  private Map<String, String> maps;

  // 4 set集合类型属性
  private Set<String> sets;

  public void setCourses(String[] courses) {
    this.courses = courses;
  }

  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(courses));
    System.out.println(list);
    System.out.println(maps);
    System.out.println(sets);
  }
}

在spring配置文件中配置

<?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">

  <!-- 1 集合类型属性注入 -->
  <bean id="stu" class="com.antherd.spring5.collectiontype.Stu">
    <!-- 数组类型注入属性 -->
    <property name="courses">
      <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="PHP" value="php"></entry>
      </map>
    </property>
    <!-- set类型注入属性 -->
    <property name="sets">
      <set>
        <value>MySQL</value>
        <value>Redis</value>
      </set>
    </property>
  </bean>
</beans>

创建测试类：TestSpring5Demo1

package com.antherd.spring5.testDemo;

import com.antherd.spring5.collectiontype.Stu;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5Demo1 {

  @Test
  public void testCollection() {
    ApplicationContext context =
        new ClassPathXmlApplicationContext("bean1.xml");
    Stu stu = context.getBean("stu", Stu.class);
    stu.test();
  }
}

细节：

在集合里面设置对象类型值

<!-- 创建多个course对象 -->
<bean id="course1" class="com.antherd.spring5.collectiontype.Course">
  <property name="cname" value="Spring5框架"></property>
</bean>
<bean id="course2" class="com.antherd.spring5.collectiontype.Course">
  <property name="cname" value="MyBatis框架"></property>
</bean>

<!-- 注入list集合类型，值是对象 -->
<property name="courseList">
  <list>
    <ref bean="course1"></ref>
    <ref bean="course2"></ref>
  </list>
</property>

Stu.java

// 学生所学多门课程
private List<Course> courseList;

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

// test方法添加
System.out.println(courseList);

Course.java

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

把集合注入部门提取出来
新建类：Book

package com.antherd.spring5.collectiontype;

import java.util.List;

public class Book {

  private List<String> list;

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

  public void test() {
    System.out.println(list);
  }
}

在spring配置文件中引入bean2.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"
  xmlns:p="http://www.springframework.org/schema/p"
  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
                      ">

  <!-- 1 提取list集合类型属性注入 -->
  <util:list id="bookList">
    <value>易筋经</value>
    <value>九阴真经</value>
    <value>九阳神功</value>
  </util:list>

  <!-- 2 提取list集合类型属性注入使用 -->
  <bean id="book" class="com.antherd.spring5.collectiontype.Book">
    <property name="list" ref="bookList"></property>
  </bean>

</beans>

测试

@Test
public void testCollection2() {
  ApplicationContext context =
      new ClassPathXmlApplicationContext("bean2.xml");
  Book book = context.getBean("book", Book.class);
  book.test();
}

IOC操作Bean管理（FactoryBean）

Spring有两种类型bean，一种普通bean，另外一种工厂bean（FactoryBean）

普通bean：在配置文件中定义的bean类型就是返回类型
工厂bean：在配置文件中定义bean类型可以和返回类型不同
创建类，让这个类作为工厂bean，实现接口FactoryBean
实现接口里面的方法，在实现的方法中定义返回的bean类型

新建类：MyBean

package com.antherd.spring5.factoryBean;

import com.antherd.spring5.collectiontype.Course;
import org.springframework.beans.factory.FactoryBean;

public class MyBean implements FactoryBean<Course> {

  // 定义返回Bean
  @Override
  public Course getObject() throws Exception {
    Course course = new Course();
    course.setCname("abc");
    return course;
  }

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

  @Override
  public boolean isSingleton() {
    return false;
  }
}

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

  <bean id="myBean" class="com.antherd.spring5.factoryBean.MyBean">
  </bean>

</beans>

测试

@Test
public void testCollection3() {
  ApplicationContext context =
      new ClassPathXmlApplicationContext("bean3.xml");
  Course course = context.getBean("myBean", Course.class);
  System.out.println(course);
}

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

在Spring里面，设置创建bean实例是单实例还是多实例
在Spring里面，默认情况下，bean是单实例对象

  @Test
  public void testCollection2() {
    ApplicationContext context =
        new ClassPathXmlApplicationContext("bean2.xml");
    Book book1 = context.getBean("book", Book.class);
    Book book2 = context.getBean("book", Book.class);
    System.out.println(book1);
    System.out.println(book2);
  }

scope属性值

singleton：默认值，表示是单实例对象，加载spring配置文件时就会创建单实例对象
prototype：表示多实例对象，不是在加载Spring配置时创建对象，在调用getBean方法时候创建多实例对象
request
session

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

多实例

IOC操作Bean管理（bean生命周期）

生命周期：从对象创建到销毁的过程

bean生命周期

通过构造器创建bean实例（无参构造器）
为bean的属性设置值和对其他bean的引用（调用set方法）
调用bean的初始化的方法（需要进行配置初始化的方法）
bean可以使用了（对象获取到了）
当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法）

新建类：Orders

package com.antherd.spring5.bean;

public class Orders {

  private String oname;

  // 无参数构造

  public Orders() {
    System.out.println("第一步 执行无参数构造创建bean实例");
  }

  public void setOname(String oname) {
    System.out.println("第二步 调用set方法设置属性的值");
    this.oname = oname;
  }

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

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

bean4.xml

<bean id="orders" class="com.antherd.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
  <property name="oname" value="手机"></property>
</bean>

测试方法

@Test
public void testBean3() {
//    ApplicationContext context =
//        new ClassPathXmlApplicationContext("bean4.xml");
  ClassPathXmlApplicationContext context =
      new ClassPathXmlApplicationContext("bean4.xml");
  Orders orders = context.getBean("myBean", Orders.class);
  System.out.println("第四步 获取创建bean的对象实例");
  System.out.println(orders);

  // 手动挡bean实例销毁
//    ((ClassPathXmlApplicationContext)context).close();
  context.close();
}

运行结果 bean的生命周期
bean的后置处理器

通过构造器创建bean实例（无参构造器）
为bean的属性设置值和对其他bean的引用（调用set方法）
把bean实例传递bean后置处理器的方法postProcessBeforeInitialization
调用bean的初始化的方法（需要进行配置初始化的方法）
把bean实例传递bean后置处理器的方法postProcessAfterInitialization
bean可以使用了（对象获取到了）
当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法）

创建后置处理器：MyBeanPost，实现接口BeanPostProcessor

package com.antherd.spring5.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPost implements BeanPostProcessor {

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

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

bean4.xml

<!-- 配置后置处理器，配置后会对所有bean执行后置处理器 -->
<bean id="myBeanPost" class="com.antherd.spring5.bean.MyBeanPost"></bean>

后置处理器

IOC操作Bean管理（xml自动装配）

根据指定的装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入

根据属性名称自动注入

<bean id="emp" class="com.antherd.spring5.autowire.Emp" autowire="byName">
<!--    <property name="dept" ref="dept"></property>-->
</bean>

根据类型自动注入(相同类型的bean不能定义多个)

<bean id="emp" class="com.antherd.spring5.autowire.Emp" autowire="byType">
<!--    <property name="dept" ref="dept"></property>-->
</bean>

IOC操作Bean管理（外部属性文件）

直接配置数据库信息
配置德鲁伊连接池
引入德鲁伊连接池依赖jar包（添加到lib文件夹，添加到项目module中）百度网盘提取码: 5ewy

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

引入外部属性文件配置数据库连接池
创建外部属性文件jdbc.properties，写数据库信息

prop.driverClass=com.alibaba.druid.pool.DruidDataSource
prop.url=http://localhost:3306/userDb
prop.username=root
prop.password=123456

把外部properties属性文件引入到spring配置文件中
* 引入context名称空间

xmlns:context="http://www.springframework.org/schema/context"
schemaLocation: http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd

在spring配置文件使用标签引入外部属性文件

IOC操作Bean管理（基于注解方式）

注解是代码特殊标记，格式：@注解名称（属性名称=属性值…）
使用注解，注解作用在类上面，方法上面，属性上面
使用注解目的：简化xml配置

Spring针对Bean管理中创建对象提供注解

@Component
@Service
@Controller
@Repository

* 上面四个注解功能是一样的，都可以用来创建bean实例
基于注解方式实现对象创建
第一步 引入Spring lib文件夹中的aop依赖spring-aop-5.2.9.RELEASE.jar
引入aop依赖
引入到项目module中
第二步 开启组件扫描
添加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:p="http://www.springframework.org/schema/p"
  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
">

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

</beans>

第三步 创建类，在类上面添加创建对象注解

package com.antherd.spring5.service;

import org.springframework.stereotype.Component;

// 在注解里面value属性值可以省略不写
// 默认值是类名称，首字母小写
// UserService -- userService
@Component(value = "userService") // <bean id = "userService" class="" />
public class UserService {

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

测试

@Test
public void testService() {
  ApplicationContext context =
      new ClassPathXmlApplicationContext("bean1.xml");
  UserService userService = context.getBean("userService", UserService.class);
  System.out.println(userService);
  userService.add();
}

开启组件扫描细节问题

<!-- 示例1
      use-default-filters="false" 表示现在不使用默认filter，自己配置filter
      context:include-filter ，设置扫描哪些内容
 -->
<context:component-scan base-package="com.antherd" use-default-filters="false">
  <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!-- 示例2
      下面配置扫描包所有内容
      context:exclude-filter：设置哪些内容不进行扫描
 -->
<context:component-scan base-package="com.antherd">
  <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

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

@Autowired：根据属性类型进行自动装配
@Qualifier：根据属性名称进行注入，需要和@Autowired一起使用，比如区分一个接口的多个实现类
@Resource：可以根据类型注入，也可以根据名称注入(javax扩展包中的注解)
@Value：注入普通类型属性

第一步把service和dao对象创建，在service和dao类添加创建对象注解
第二步在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解

package com.antherd.spring5.dao;

public interface UserDao {
  void add();
}

package com.antherd.spring5.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao {

  @Override
  public void add() {
    System.out.println("dao add...........");
  }
}

package com.antherd.spring5.service;

import com.antherd.spring5.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

// 在注解里面value属性值可以省略不写
// 默认值是类名称，首字母小写
// UserService -- userService
@Service
public class UserService {

  @Value(value = "abc")
  private String name;

  // 定义dao类型属性
  // 不需要添加set方法
  // 添加注入属性注解
  @Autowired // 根据类型进行注入
  private UserDao userDao;

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

完全注解开发

创建配置类，替代xml配置文件

package com.antherd.spring5.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

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

}

编写测试类

@Test
public void testService2() {
  ApplicationContext context =
      new AnnotationConfigApplicationContext(SpringConfig.class);
  UserService userService = context.getBean("userService", UserService.class);
  System.out.println(userService);
  userService.add();
}

geyiwei-suzhou

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring5 框架【二】 IOC容器

视频链接：2020最新版SpringCloud框架开发教程-周阳文章源码：https://github.com/geyiwei-suzhou/spring5/IOC底层原理什么是IOC？（1）控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理（2）使用IOC目的：为了耦合度降低（3）入门案例就是IOC实现IOC底层原理（1）xml解析、工厂模式、反射（2）图解IOC底层原理原始方式工厂模式：降低耦合度IOC过程：进一步降低耦合度IOC接口（BeanFactor.
复制链接

扫一扫

专栏目录