spring学习-IOC容器

最新推荐文章于 2024-07-10 21:37:49 发布

置顶暮同学

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量249

点赞数

分类专栏： spring学习文章标签： java spring intellij idea

本文链接：https://blog.csdn.net/weixin_45882657/article/details/109168827

版权

spring学习专栏收录该内容

2 篇文章 0 订阅

订阅专栏

概述

Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用 Spring框架来创建性能好、易于测试、可重用的代码。
Spring 框架是一个开源的 Java 平台，它最初是由 Rod Johnson编写的，并且于 2003 年 6 月首次在 Apache 2.0 许可下发布。
Spring 是轻量级的框架，其基础版本只有 2 MB 左右的大小。
Spring 框架的核心特性是可以用于开发任何 Java 应用程序，但是在 Java EE 平台上构建 web 应用程序是需要扩展的。 Spring 框架的目标是使 J2EE 开发变得更容易使用，通过启用基于 POJO编程模型来促进良好的编程实践。

链接:
什么是spring框架

spring优点

低侵入式设计，代码污染极低
独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once,Run Anywhere的承诺
Spring的DI机制降低了业务对象替换的复杂性，提高了组件之间的解耦
Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好的复用
Spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问
Spring并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部，

Spring 体系结构

Spring 框架提供约 20 个模块，可以根据应用程序的要求来使用。

spring核心容器

核心容器由spring-core，spring-beans，spring-context，spring-context-support和spring-expression（SpEL，Spring表达式语言，Spring Expression Language）等模块组成，它们的细节如下：

spring-core模块提供了框架的基本组成部分，包括 IoC 和依赖注入功能。
spring-beans 模块提供 BeanFactory，工厂模式的微妙实现，它移除了编码式单例的需要，并且可以把配置和依赖从实际编码逻辑中解耦。
context模块建立在由core和 beans模块的基础上建立起来的，它以一种类似于JNDI注册的方式访问对象。Context模块继承自Bean模块，并且添加了国际化（比如，使用资源束）、事件传播、资源加载和透明地创建上下文（比如，通过Servelet容器）等功能。Context模块也支持JavaEE的功能，比如EJB、JMX和远程调用等。
ApplicationContext接口是Context模块的焦点。spring-context-support提供了对第三方库集成到Spring上下文的支持，比如缓存（EhCache,Guava,
JCache）、邮件（JavaMail）、调度（CommonJ, Quartz）、模板（FreeMarker, JasperReports, Velocity）等。
spring-expression模块提供了强大的表达式语言，用于在运行时查询和操作对象图。它是JSP2.1规范中定义的统一表达式语言的扩展，支持set和get属性值、属性赋值、方法调用、访问数组集合及索引的内容、逻辑算术运算、命名变量、通过名字从SpringIoC容器检索对象，还支持列表的投影、选择以及聚合等。

它们的完整依赖关系如下图所示：
spring构造图

spring案例

基于idea 创建maven项目。首先导入spring框架的核心JAR包

    <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-context</artifactId>
           <version>5.2.6.RELEASE</version>
   </dependency>

项目中创建一个普通类我们添加一个普通的方法

@Data
public class User {
    //一个普通的add方法 用于测试User类是否被创建
    public  void add(){
        System.out.println("add方法被创建了...");
    }
}

创建 bean 的配置文件bean.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-3.0.xsd">

    <!-- 配置User对象创建-->
    <bean id="user" class="com.ys.entity.User">
    </bean>
</beans>

创建调用bean.xml的测试用例

   @Test
    public void addTest(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        User user = context.getBean("user", User.class);
        System.out.println(user.toString());
        user.add();
    }

输出

User()
add方法被创建了...

什么是IOC

控制反转就是把传统的创建对象和对象之间的调用过程交给spring进行管理（传统的new创建对象方式）
使用IOC的目的是为了降低耦合程度（无法完全消除耦合只能最大限度的降低）
入门案例就是一个完成的IOC模式获取User的对象交由spring xml配置方式创建

IOC底层原理

xml解析，工厂模式，反射机制

传统模式 （耦合度太高了调用Dao.add 需要先创建UserDao对象）
在这里插入图片描述
工厂模式 （降低了 Service和Dao的耦合但是与Factory产生了耦合）

IOC创建过程 （通过xml解析，反射机制进一步降低了与工厂类的耦合度）

IOC容器（BeanFactory ApplicationContext）

IOC思想基于IOC容器完成而IOC容器的底层实现就是对象工厂
Spring提供了IOC容器的两种实现方式：（两个接口）
Spring 的 BeanFactory 接口

这是一个最简单的容器，它主要的功能是为依赖注入（DI）提供支持。
这个容器接口在org.springframework.beans.factory.BeanFactor 中被定义。BeanFactory 和相关的接口，比如BeanFactoryAware、DisposableBean、InitializingBean，仍旧保留在 Spring中，主要目的是向后兼容已经存在的和那些 Spring 整合在一起的第三方框架。
在 Spring 中，有大量对 BeanFactory接口的实现。其中，最常被使用的是 XmlBeanFactory 类。这个容器从一个 XML 文件中读取配置元数据，由这些元数据来生成一个被配置化的系统或者应用
特点：
加载配置文件的时候不会去创建对象，而是在获取使用对象的时候才会被创建

ApplicationContext 是 BeanFactory 的子接口，也被成为 Spring 上下文。

Application Context 是 spring 中较高级的容器。和 BeanFactory 类似，它可以加载配置文件中定义的 bean，将所有的 bean 集中在一起，当有请求的时候分配 bean。
另外，它增加了企业所需要的功能，比如，从属性文件中解析文本信息和将事件传递给所指定的监听器。这个容器在org.springframework.context.ApplicationContext interface 接口中定义。
ApplicationContext 包含 BeanFactory 所有的功能，一般情况下，相对于
BeanFactory，ApplicationContext 会更加优秀。
特点：
加载配置文件的时候就已经会把配置文件中的对象进行创建

代码演示

    public void addTest(){
        // 加载spring配置文件
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        //获取配置创建的对象
        User user = context.getBean("user", User.class);
        user.add();
        // 加载spring配置文件
        BeanFactory factory = new ClassPathXmlApplicationContext("bean.xml");
        // 获取配置创建的对象
        User user1 = factory.getBean("user", User.class);
        user1.add();
    }

运行效果

add方法被创建了...
add方法被创建了...

Spring Bean作用域

当在 Spring 中定义一个 bean 时，你必须声明该 bean 的作用域的选项。例如，为了强制 Spring 在每次需要时都产生一个新的 bean 实例，你应该声明 bean 的作用域的属性为 prototype。同理，如果你想让 Spring在每次需要时都返回同一个bean实例，你应该声明 bean 的作用域的属性为 singleton。
Spring 框架支持以下五个作用域，分别为singleton、prototype、request、session和global session，5种作用域说明如下所示，注意，如果你使用 web-aware ApplicationContext 时，其中三个是可用的。

作用域	描述
singleton	在spring IoC容器仅存在一个Bean实例，Bean以单例方式存在，默认值
prototype	每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时，相当于执行newXxxBean()
request	每次HTTP请求都会创建一个新的Bean，该作用域仅适用于WebApplicationContext环境
session	同一个HTTP Session共享一个Bean，不同Session使用不同的Bean，仅适用于WebApplicationContext环境
global-session 方法	一般用于Portlet应用环境，该运用域仅适用于WebApplicationContext环境

singleton 作用域：

1. singleton 是默认的作用域，也就是说，当定义 Bean 时，如果没有指定作用域配置项，则 Bean 的作用域被默认为 singleton。当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。
2. 也就是说，当将一个bean定义设置为singleton作用域的时候，Spring IoC容器只会创建该bean定义的唯一实例。
3. Singleton是单例类型，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象。注意，Singleton作用域是Spring中的缺省作用域。

代码演示：

  <!-- singleton属性是默认是  当没有指定作用域配置项时 默认为singleton-->
    <bean id="user" class="com.ys.entity.User" scope="singleton">
    </bean>

  // 加载spring配置文件
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        //获取配置创建的对象
        User user = context.getBean("user", User.class);
        User user2 = context.getBean("user", User.class);
        System.out.println(user.toString());
        System.out.println(user2.toString());
        boolean flag = user == user2;
        System.out.println(flag);

    }

com.ys.entity.User@515c6049
com.ys.entity.User@515c6049
true

prototype 作用域：

当一个bean的作用域为Prototype，表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。根据经验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。

调整xml scope

 <bean id="user" class="com.ys.entity.User" scope="prototype">
    </bean>

com.ys.entity.User@206a70ef
com.ys.entity.User@292b08d6
false

Spring Bean 生命周期

当一个 bean 被实例化时，它可能需要执行一些初始化使它转换成可用状态。同样，当 bean 不再需要，并且从容器中移除时，可能需要做一些清除工作

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

代码演示：

public class User {

    private String name;  // 名称

    public User() {
        System.out.println("第一步调用User类中无参构造函数用于创建bean实例" );
    }

    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配置

  <bean id="user" class="com.ys.entity.User" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="名称注入"></property>
    </bean>

测试用例：

   ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        // 第四步获取创建bean实例对象
        User user = context.getBean("user", User.class);
        System.out.println("第四步获取创建bean实例对象");
        // 手动销毁 bean实例
        context.close();
        System.out.println("bean实例被销毁了");

第一步调用User类中无参构造函数用于创建bean实例
第二步调用set方法设置属性值
第三步 执行初始化的方法
第四步获取创建bean实例对象
第五步 执行销毁的方法
bean实例被销毁了

Bean管理操作的两种方式

什么是Bean管理

Bean管理的两个操作
由Spring创建对象
由Spring注入属性

两种方式

基于xml配置文件的方式实现
基于注解方式实现

IOC操作Bean管理(基于Xml方式)

在spring配置文件中，使用bean标签，标签里添加对应属性对象，就可以实现对应的对象的创建(默认使用无参构造函数创建对象)

 <bean id="user" class="com.ys.entity.User"></bean>

在bean标签中有很多的属性如下列所示

属性	描述
calss	这个属性是强制性的，并且指定用来创建 bean 的 bean 类。
name	这个属性指定唯一的 bean 标识符。在基于 XML 的配置元数据中，你可以使用 ID 和/或 name 属性来指定 bean 标识符。
scope	这个属性指定由特定的 bean 定义创建的对象的作用域
lazy-initialization mode	延迟初始化的 bean 告诉 IoC 容器在它第一次被请求时，而不是在启动时去创建一个 bean 实例
initialization 方法	在 bean 的所有必需的属性被容器设置之后，调用回调方法
destruction 方法	当包含该 bean 的容器被销毁时，使用回调方法。

Bean 与 Spring 容器的关系

DI依赖注入注入属性

使用Set方法进行注入（无参）

代码演示：

@Data
public class Book {
    private  String name;
    private  String address;
    public static void main(String[] args) {
        Book book = new Book();
        book.setAddress("上海");
        book.setName("书名");
        System.out.println(book.toString());
    }
}

输出：

Book(name=书名, address=上海)

在spring配置文件配置对象创建：

代码演示：

  <bean id="book" class="com.ys.entity.Book">
        <!--使用 property 完成属性注入
         name：类里面属性名称
         value：向属性注入的值
          -->
        <property name="name" value="spring"></property>
        <property name="address" value="上海"></property>
    </bean>

测试用例：

public class springTest {
    @Test
    public void addTest(){
        // 加载spring配置文件
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        //获取配置创建的对象
        Book book = context.getBean("book", Book.class);
        System.out.println(book.toString());
        
    }

}

输出：

Book(name=spring, address=上海)

使用有参数构造进行注入：（无参构造）
代码演示

@Data
public class Book {
    private  String name;
    private  String address;

    // 创建对象默认调用无参构造函数 当声明有参构造函数方法时 需要手动创建无参构造函数
    public Book() {

    }
    public Book(String name, String address) {
        this.name = name;
        this.address = address;
    }

    public static void main(String[] args) {
        Book book = new Book("mybatis" ,"北京");
        System.out.println(book.toString());
    }
}

输出：

Book(name=mybatis, address=北京)

在spring配置文件配置对象创建：(有参构造函数)
代码演示：

    <bean id="book1" class="com.ys.entity.Book">
        <!--使用 property 完成属性注入
         name：类里面属性名称
         value：向属性注入的值
          -->
        <constructor-arg name="name" value="Mybatis"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
        <!-- 使用索引下标值 注入参数 
        <constructor-arg index="0"  value="Mybatis"></constructor-arg>
        <constructor-arg index="1" value="China"></constructor-arg>
        -->
    </bean>

测试用例：

   @Test
    public void addTest(){
        // 加载spring配置文件
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        //获取配置创建的对象
        Book book = context.getBean("book1", Book.class);
        System.out.println(book.toString());

    }

输出：

Book(name=Mybatis, address=China)

p 名称空间注入（了解）

使用 p 名称空间注入，可以简化基于 xml 配置方式

1. 添加 p 名称空间在配置文件中

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

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

<!-- 使用p名称进行属性注入-->
    <bean id="book2" class="com.ys.entity.Book" p:name="Mysql" p:address="China">
    </bean>

xml 注入其他类型属性

1. 注入属性-外部bean

传统方式调用外部bean
代码演示：

public interface UserDao{
    /**
     * 一个执行方法 返回值void
     */
    void save();
}

public class UserDaoImpl implements UserDao {

    @Override
    public void save() {
        System.out.println("save.success");

    }
}

public class UserService {
    public void add() {
        System.out.println("Service.add success");

        //1 在Service中先创建UserDao对象
        //2 多态创建UserDao对象
        UserDao userDao = new UserDaoImpl();
        userDao.save();
    }
}

测试用例：

    public static void main(String[] args) {
        UserService userService = new UserService();
        userService.add();
    }

输出：

Service.add success
save.success

基于spring配置xml方式进行调用外部bean处理

代码演示：

UserService UserDao 以及Dao的实现类

@Data
public class UserService {

    //1 创建UserDao类型属性 生成get set方法 此处由lombok自动生成
    private  UserDao userDao;

    public void add() {
        System.out.println("Service.add success");
        userDao.save();
    }

public interface UserDao{
    /**
     * 一个执行方法 返回值void
     */
    void save(); }

public class UserDaoImpl implements UserDao {

    @Override
    public void save() {
        System.out.println("save.success");

    } }

xml配置：

  <bean id = "userService" class="com.ys.service.UserService">
        <!-- 注入UserDao对象
           name标签：类里面的属性名称{
           private UserDao userDao;
           }
          ref标签：用于创建对象类型{
          bean标签id值 userDaoImpl对象 把外部bean注入进来
          }
        -->
        <property name="userDao" ref="userDao">

        </property>
    </bean>
    <!-- UserDao是个接口类型 所以不能直接创建对象  所以创建它的实现类 UserDaoImpl -->
    <bean id = "userDao" class="com.ys.dao.UserDaoImpl"></bean>

测试用例：

    public void addTest(){
        // 加载spring配置文件
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        //获取配置创建的对象
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService.toString());
        userService.add();

    }

输出：
Service.add success
save.success

2. 注入属性-内部 bean
代码演示：

@Data
public class User {
// 用户类
    private String uName; // 用户名称
    private String uCode; // 用户编号
    private Factory factory;  // 所属工厂
}

@Data
public class Factory {
// 工厂类
    private String fName;  // 工厂名称


}

xml配置：

    <!--内部 bean-->
    <bean id="user" class="com.ys.bean.User">
        <!--设置两个普通属性-->
        <property name="UName" value="Uzi"></property>
        <property name="UCode" value="LPL003"></property>
        <!--设置对象类型属性-->
        <property name="factory">
            <bean id="factory" class="com.ys.bean.Factory">
                <property name="FName" value="杭州工厂"></property>
            </bean>
        </property>
    </bean>

测试用例：

    @Test
    public void beanTest(){
       ApplicationContext context = new ClassPathXmlApplicationContext("beanXml.xml");
        User user = context.getBean("user", User.class);
        System.out.println(user.toString());

    }

}

输出：

User(uName=Uzi, uCode=LPL003, factory=Factory(fName=杭州工厂))

其他方式：

 <!-- 级联赋值 外部bean -->
    <bean id="user1" class="com.ys.bean.User">
        <property name="UName" value="ClearLove"></property>
        <property name="UCode" value="LPL001"></property>
        <property name="factory" ref="factory"></property>
        <property name="factory.FName" value="教练组"></property>
    </bean>
    <bean id="factory" class="com.ys.bean.Factory">
        <property name="fName" value="教练组2"></property>
    </bean>

输出：

User(uName=ClearLove, uCode=LPL001, factory=Factory(fName=教练组))

xml 注入集合属性

注入数组类型属性
注入List集合类型属性
注入Map集合类型属性
注入Set集合类型属性

代码演示：

@Data
public class Dept {

    private String[] args;   //数组类型属性
    private List<String> list; //List集合类型属性
    private Map<String, String> maps;  //map类型属性
    private Set<String> sets;  // set结合类型属性
}


    <bean id="dept" class="com.ys.entity.Dept">
        <!--数组类型属性注入-->
        <property name="args">
            <array>
                <value>数组1</value>
                <value>数组2</value>
            </array>
        </property>
        <!--list类型属性注入-->
        <property name="list">
            <list>
                <value>list1</value>
                <value>list2</value>
            </list>

        </property>
        <!--map类型属性注入-->
        <property name="maps">
            <map>

                <entry key="key1" value="value1"></entry>
                <entry key="key2" value="value2"></entry>

            </map>
        </property>
        <!--set类型属性注入-->
        <property name="sets">
            <set>
                <value>set1</value>
                <value>set2</value>
            </set>
        </property>
    </bean>
</beans>

Dept(args=[数组1, 数组2], list=[list1, list2], maps={key1=value1, key2=value2}, sets=[set1, set2])

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

@Data
public class Dept {

    private String[] args;   //数组类型属性
    private List<String> list; //List集合类型属性
    private Map<String, String> maps;  //map类型属性
    private Set<String> sets;  // set结合类型属性
    private List<User> userList; // 集合里面设置对象类型赋值
}

       <!--注入list集合类型 值是对象类型 -->
        <property name="userList">
            <list>
                <ref bean="user1"></ref>
                <ref bean="user2"></ref>
            </list>
        </property>
    </bean>

<!--创建多个user对象-->
    <bean id = "user1" class="com.ys.entity.User">
        <property name="name" value="userList1"></property>
    </bean>

    <bean id = "user2" class="com.ys.entity.User">
        <property name="name" value="userList2"></property>
    </bean>

Dept(args=[数组1, 数组2], list=[list1, list2], maps={key1=value1,
key2=value2}, sets=[set1, set2], userList=[User(name=userList1),
User(name=userList2)])

把集合注入部分提取出来

<?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 id="listBean">
        <value>userList1</value>
        <value>userList2</value>
    </util:list>
    <bean id="dept" class="com.ys.entity.Dept">
        <property name="list" ref="listBean">
        </property>
     </bean>

Dept(args=[数组1, 数组2], list=[userList1, userList2], maps={key1=value1,
key2=value2}, sets=[set1, set2], userList=null)

xml自动装配（byName/byType）

什么是自动装配：

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

@Data
public class Order {
    //一个订单属于某一个工厂
    private String oName; // 订单名称
    private String oCode; // 订单编码
    private Factory factory; // 工厂类
}

@Data
public class Factory {
    private String  fName; // 工厂名称
}

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

    <!--实现自动装配
     bean 标签属性 autowire，配置自动装配
     autowire 属性常用两个值：
     byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
     byType 根据属性类型注入
    -->
    <!--这里也可以换成byName-->
    <bean id="order" class="com.ys.autowire.Order" autowire="byType">
        <property name="OName" value="订单名称"></property>
        <property name="OCode" value="订单编码"></property>
    </bean>

    <bean id="factory" class="com.ys.autowire.Factory">
        <property name="FName" value="工厂名称"></property>
    </bean>
</beans>

Order(oName=订单名称, oCode=订单编码, factory=Factory(fName=工厂名称))

xml注入外部属性文件

连接数据库为例

传统方式直接配置数据库连接信息

@Data
public class DataSource {
    
    // 用于创建数据库连接信息
    private String driverClassName; // 数据库驱动
    private String url;  // 数据库连接url
    private String username;  // 用户名
    private String password;  // 密码
}

xml配置：

   <!--手动配置 jdbc信息
        可以根据自己数据库配置 替换成自己的配置信息
    -->
    <bean id="dataSource" class="com.ys.jdbc.DataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url"
                  value="jdbc:mysql://localhost:3306/spring"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>

jdbcTest:

 @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("jdbc.xml");
        DataSource dataSource = context.getBean("dataSource", DataSource.class);
        // mysql驱动名
        String driverClassName = dataSource.getDriverClassName();
        // 数据库链接URL
        String url = dataSource.getUrl();
        // 账号密码
        String username = dataSource.getUsername();
        String password = dataSource.getPassword();
        System.out.println(url);
        System.out.println(dataSource);
        Connection conn = null;//声明一个连接对象
        Statement stmt = null;
        try {
            // 注册 JDBC 驱动
            System.out.println("开始注册");
            Class.forName(driverClassName);
            // 打开链接
            System.out.println("连接数据库...");
            conn = DriverManager.getConnection(url, username, password);
            // 执行查询
            System.out.println(" 实例化Statement对象...");
            stmt = conn.createStatement();
            String sql;
            sql = "SELECT * FROM account ";
            ResultSet rs = stmt.executeQuery(sql);
            // 展开结果集数据库
            while (rs.next()) {
                // 通过字段检索
                int id = rs.getInt("id");
                String name = rs.getString("name");
                float money = rs.getFloat("money");
                // 输出数据
                System.out.print("id: " + id);
                System.out.print("name: " + name);
                System.out.print("money: " + money);
            }
            System.out.println(rs);
            // 完成后关闭
            rs.close();
            stmt.close();
            conn.close();
        } catch (SQLException se) {
            // 处理 JDBC 错误
            se.printStackTrace();
        } catch (Exception e) {
            // 处理 Class.forName 错误
            e.printStackTrace();
        } finally {
            // 关闭资源
            try {
                if (stmt != null) stmt.close();
            } catch (SQLException se2) {
            }// 什么都不做
            try {
                if (conn != null) conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
        }
        System.out.println("Goodbye!");

配置成功：

jdbc:mysql://localhost:3306/spring
DataSource(driverClassName=com.mysql.jdbc.Driver,
url=jdbc:mysql://localhost:3306/spring, username=root,password=123456)
开始注册连接数据库…
实例化Statement对象…
id: 1 name: aaa money:1000.0 id: 2 name: bbb money: 1000.0 id: 3 name: ccc money: 1000.0
com.mysql.jdbc.ResultSet@44c03695
Goodbye!

2. 引入外部属性文件进行配置数据库连接信息

创建外部属性文件，properties 格式文件，写数据库信息创建jdbc.properties文件


prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/spring
prop.username=root
prop.password=123456

xml配置：

<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">
    <!--引入context名称标签-->

    <!--在 spring 配置文件使用标签引入外部属性文件-->
    <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--配置连接池-->
    <bean id="dataSource1" class="com.ys.jdbc.DataSource">
        <property name="driverClass" 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>

jdbc:mysql://localhost:3306/spring
DataSource(driverClass=com.mysql.jdbc.Driver,
url=jdbc:mysql://localhost:3306/spring, username=root,
password=123456) 开始注册连接数据库… 实例化Statement对象… id: 1/name:
aaa/money: 1000.0id: 2/name: bbb/money: 1000.0id: 3/name: ccc/money:
1000.0Goodbye!

IOC操作Bean管理(基于注解方式)

什么是注解：

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

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

@Component
@Service
@Controller
@Repository

在类的上面添加注解测试

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

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

开启组件扫描细节配置

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

测试成功：

UserService() add.success


  <!--
         component-scan 有默认属性 ： use-default-filters="false"
         表示现在不使用默认 filter，自己配置 filter
         context:include-filter ，设置扫描哪些内容
         expression="org.springframework.stereotype.Repository
         只会扫描repository注解  也可以设置成别的 Service 之类的
    -->
        <context:component-scan base-package="com.ys" use-default-filters="false">
            <context:include-filter type="annotation"
             <!--context:exclude-filter
            表示扫描不包含设置内容的注解
            --> expression="org.springframework.stereotype.Repository"/>
        </context:component-scan>

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

@Autowired：根据属性类型进行自动装配
@Qualifier：根据名称进行注入
@Resource：可以根据类型注入，可以根据名称注入
@Value：注入普通类型属性

xml配置开启自动扫描：

public interface UserDao {
// 一个普通的方法 生成userDao的实现类
    void save();
}
@Service
public class UserDaoImpl implements UserDao {

    @Override
    public void save() {
        System.out.println("userDao.save ");
    }
}
@Service
public class UserService {

/**
 * @Autowired
 * 根据属性类型进行自动装配
 * 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解
*/
/**
 * @Autowired
 * @Qualifier(value = "userDaoImpl") ： 根据名称进行注入（自动装配）
 * 需要和@Autowired 搭配起来使用 常用于一个接口拥有许多实现类 根据具体名称自动装配 @Service创建对象时默认小写名称值
 */

// @Resource
@Resource(name ="userDaoImpl")
/**
 * 可以根据类型注入，可以根据名称注入  分情况进行使用
 * 来源java javax扩展包 所以spring 更建议使用spring下的注解
 */
    UserDao userDao;
    @Value(value = "name") // 注入普通类型属性 对属性进行赋值
    private String name;
    public void add() {
        System.out.println("add.success");
        userDao.save();
    }
}

测试结果:

com.ys.service.UserService@378542de add.success userDao.save

完全注解开发

创建配置类用于替代xml配置

@Configuration  // 作用于替代xml配置
@ComponentScan(basePackages = {"com.ys"}) // 相当于xml配置的组件扫描
public class SpringConfig {

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

摒弃了xml配置

com.ys.service.UserService@e15b7e8 add.success userDao.save

暮同学

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
spring学习-IOC容器

概述Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用 Spring框架来创建性能好、易于测试、可重用的代码。Spring 框架是一个开源的 Java 平台，它最初是由 Rod Johnson编写的，并且于 2003 年 6 月首次在 Apache 2.0 许可下发布。Spring 是轻量级的框架，其基础版本只有 2 MB 左右的大小。Spring 框架的核心特性是可以用于开发任何 Java 应用程序，但是在 Java EE 平台上构建 web 应
复制链接

扫一扫