Spring-概述与IOC容器

UndefinedException

已于 2022-07-15 20:54:18 修改

阅读量260

点赞数 1

分类专栏： Spring5 文章标签： spring

于 2022-07-15 20:51:38 首次发布

本文链接：https://blog.csdn.net/weixin_62427168/article/details/125807496

版权

Spring5 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

2.3.4 注入外部bean（例如Service->DAO）

2.3.5 注入内部Bean（员工、部门表）

2.3.6 级联赋值（员工、部门表）

2.3.7 注入集合属性

2.3.8 bean 实例是单实例还是多实例

2.3.9 bean的生命周期

2.3.10 xml自动装配

2.3.11 引入外部属性文件（配置数据库连接池）

一、基本概念与环境搭建

1、Spring 是轻量级的开源的 JavaEE 框架

2、Spring 可以解决企业应用开发的复杂性

3、Spring 有两个核心部分：IOC 和 Aop

（1）IOC：控制反转，把创建对象过程交给 Spring 进行管理

（2）Aop：面向切面，不修改源代码进行功能增强

spring的特点：

（1）方便解耦，简化开发

（2）Aop 编程支持

（3）方便程序测试

（4）方便和其他框架进行整合

（5）方便进行事务操作

（6）降低 API 开发难度

maven依赖：

<dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.10</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.10</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.10</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.3.10</version>
        </dependency>
</dependencies>

基本结构：

1.普通java类 2.spring配置文件xml

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

... ...

</beans>

基本功能测试：

//user类
public class User {
     public void add() {
     System.out.println("add......");
     }
}

//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">
     <!--配置 User 对象创建--> 
     <bean id="user" class="com.spring5.User"></bean>
</beans>

//测试
@Test
public void testAdd() {
 //1 加载 spring 配置文件
 ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
 //2 获取配置创建的对象
 User user = context.getBean("user", User.class);
 user.add();
}

二、IOC-控制反转

2.1 概念

什么是控制反转？

（1）控制反转，就是把对象创建和对象之间的调用过程，交给 Spring 的IOC容器进行管理

（2）使用 IOC 目的：为了降低耦合度

底层原理？

涉及到了xml 解析、工厂模式、反射。

IOC 容器实际上是一个map（K，V），底层是对象工厂。我们创建对象时不会直接去new出来，而是先将xml文件中定义的bean解析出来，利用对象工厂创建出对应类的实例对象，进行初始化等操作。创建类的实例的过程就用到了反射的机制。

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

        （1）BeanFactory：IOC 容器的基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用

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

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

        * 加载配置文件时就会把在配置文件对象进行创建（饿汉）

实现类：

          FileSystemXmlApplicationContext

                ClassPathXmlApplicationContext

2.2 Bean管理

Bean 管理指的就是两个操作：

（1）Spring 创建对象

（2）Spirng 注入属性（依赖注入-DI）

注：依赖注入是一种消除类之间依赖关系的设计模式。例如，A类要依赖B类，A类不再直接创建B类，而是把这种依赖关系配置在外部xml文件（或java config文件）中，然后由Spring容器根据配置信息创建、管理bean类，降低了类之间的耦合性。A类依赖B类，A类和B类之间存在紧密耦合，如果把依赖关系变为A类依赖B的父类B+类，在A类与B+类的依赖关系下，A类可使用B+类的任意子类，A类与B+类的子类之间的依赖关系是松耦合的。可以看到依赖注入的基础是多态机制与反射机制。

实现方式：

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

（2）基于注解方式实现

2.3 基于xml的Bean管理

2.3.1 创建对象

使用<Bean>标签创建对象，主要属性：

id-唯一标识

class-类的全路径

*创建对象时，默认执行无参构造完成对象创建

2.3.2 使用set方法注入属性

public class Book {
 //创建属性
 private String bname;

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

<bean id="book" class="com.spring5.Book">
     <!--使用 property 完成属性注入
     name：类里面属性名称
     value：向属性注入的值
     -->
 <property name="bname" value="JAVA高级教程"></property>
 <!--如果在标签体内写<null/>,表明注入null值-->

</bean>

2.3.3 使用有参数构造注入属性

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

 //有参数构造
 public Orders(String oname) {
     this.oname = oname;

     }
}

<bean id="orders" class="com.spring5.Orders">
     <constructor-arg name="oname" value="电脑"></constructor-arg>
</bean>

2.3.4 注入外部bean（例如Service->DAO）

外部bean:在beans标签内部定义的bean对象，外部bean可以被多个bean对象引用

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();
 }
}

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

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

2.3.5 注入内部Bean（员工、部门表）

内部bean:在某个bean标签内部定义的bean对象，内部bean只能被一个对象的某个属性引用。

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

2.3.6 级联赋值（员工、部门表）

<bean id="emp" class="com.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.spring5.bean.Dept">
     <property name="dname" value="财务部"></property>
</bean>

2.3.7 注入集合属性

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

    get/set方法...
}

<!--1 集合类型属性注入-->
<bean id="stu" class="com.spring5.collectiontype.Stu">
 <!--数组类型属性注入-->
     <property name="array">
     <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>

假如集合是对象类型的，如：List<Course> CourseList ,应按照下面的格式注入：

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

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

2.3.8 bean 实例是单实例还是多实例

默认情况下，bean 是单实例对象。

若要设为多实例对象，应该设置bean标签的scope属性：

第一个值默认值，singleton，表示是单实例对象

第二个值 prototype，表示是多实例对象

-设置 scope 值是 singleton 时，加载 spring 配置文件时候就会创建单实例对象

-设置 scope 值是 prototype 时，不是在加载 spring 配置文件时候创建对象，在调用 getBean 方法时创建多实例对象

2.3.9 bean的生命周期

bean 生命周期有七步：

（1）通过构造器创建 bean 实例（无参数构造）

（2）为 bean 的属性赋值和对其他 bean 引用（调用 set 方法）

（3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization

（4）调用 bean 的初始化的方法（需要进行配置初始化的方法）

（5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization

（6）bean 可以使用了（对象获取到了）

（7）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

2.3.10 xml自动装配

手动装配是手动地将bean中所关联的其他bean装配进去，

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

通过设置bean标签的属性 autowire，可以实现自动装配。

autowire 属性常用两个值：

1.byName 根据属性名称注入，Spring会根据class属性找到实体类，然后查询实体类中所有setter方法的名字，根据setter方法后面的名字，再到配置文件中寻找一个与该名字相同id的Bean，注入进来

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

2. byType 根据属性类型自动注入，Spring会自动寻找一个与该属性类型相同的Bean，注入进来

使用byType方式必须保证配置文件中所有bean的class属性的值是唯一的，否则就会报错

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

2.3.11 引入外部属性文件（配置数据库连接池）

（1）创建外部属性文件，properties 格式文件，写数据库信息

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8
jdbc.username=root
jdbc.password=310333

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

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

//在 spring 配置文件使用标签引入外部属性文件
<!--引入外部属性文件-->
<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>

2.4 基于注解的Bean管理

（1）注解是代码的特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值..)

（2）使用注解，注解作用在类上面，方法上面，属性上面

（3）使用注解目的：简化 xml 配置

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

（1）@Component

（2）@Service

（3）@Controller

（4）@Repository

-上面四个注解功能是一样的，都可以用来创建 bean 实例

2.4.1 开启组件扫描

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

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

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

组件扫描的细节：

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

<!--
 context:exclude-filter： 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.spring5">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

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

（1）@Autowired：根据属性类型进行自动装配

第一步把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解

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

@Service
public class UserService {
 //定义 dao 类型属性
 //不需要添加 set 方法
 //添加注入属性注解
 @Autowired 
 private UserDao userDao;

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

（2）@Qualifier：根据名称进行注入,@Qualifier 注解需要和上面@Autowired 一起使用：

//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

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

//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

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

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

2.4.3 完全注解开发

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

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

（2）测试

ApplicationContext context= new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService", UserService.class);

UndefinedException

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring-概述与IOC容器

1、Spring 是轻量级的开源的 JavaEE 框架2、Spring 可以解决企业应用开发的复杂性3、Spring 有两个核心部分：IOC 和 Aop（1）IOC：控制反转，把创建对象过程交给 Spring 进行管理（2）Aop：面向切面，不修改源代码进行功能增强.........
复制链接

扫一扫