spring框架学习笔记01（Ioc+xml）

01spring概述

1.1 spring 是什么?

Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring
MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架

1.2spring的优势

方便解耦，简化开发
通过 Spring 提供的 IoC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
AOP 编程的支持
通过 Spring 的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付。
声明式事务的支持
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。
方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
方便集成各种优秀框架
Spring 可以降低各种框架的使用难度，提供了对各种优秀框架（ Struts、 Hibernate、 Hessian、 Quartz等）的直接支持。
降低 JavaEE API 的使用难度
Spring 对 JavaEE API（如 JDBC、 JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的使用难度大为降低。

1.3spring的体系结构

在这里插入图片描述

02何为程序的耦合?

程序的耦合
耦合：程序间的依赖关系
包括：
类之间的依赖(A类调用或者继承B类，A类就依赖B类)
方法间的依赖（A方法调用B方法，A方法就依赖B方法）
解耦
降低程序间的依赖关系
实际开发中：应该做到：编译期不依赖，运行时才依赖。
解耦的思路：
第一步：使用反射来创建对象，而避免使用new关键字。
第二步：通过读取配置文件来获取要创建的对象全限定类名

2.1使用JDBC进行耦合演示：

在这里插入图片描述

2.1.1创建一个maven工程（spring）

导入mysql坐标

<packaging>jar</packaging>
    <dependencies>
        <!--mysql依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.26</version>
        </dependency>
    </dependencies>

2.1.2创建数据库和表

数据库（mySpring）：

create table account(
	id int primary key auto_increment,
	name varchar(40),
	money float
)character set utf8 collate utf8_general_ci;

表（account）：

insert into account(name,money) values('aaa',1000);
insert into account(name,money) values('bbb',1000);
insert into account(name,money) values('ccc',1000);

2.1.3在包中编写一个jdbcDemo1.java类

public class JdbcDemo1 {
    public static void main(String[] args) throws  Exception{
        //1.注册驱动
        //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        Class.forName("com.mysql.jdbc.Driver");
        //2.获取连接
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mySpring","root","12345678");
        //3.获取操作数据库的预处理对象
        PreparedStatement pstm = conn.prepareStatement("select * from account");
        //4.执行SQL，得到结果集
        ResultSet rs = pstm.executeQuery();
        //5.遍历结果集
        while(rs.next()){
            System.out.println(rs.getString("name"));
        }
        //6.释放资源
        rs.close();
        pstm.close();
        conn.close();
    }
}

分析：
DriverManager.registerDriver(new com.mysql.jdbc.Driver());，如果使用这种方式注册JDBC驱动（使用new关键字），编译期就会产生依赖，如果我们把pom文件里面的mysql依赖注释掉，就会立马爆红，更没办法编译。
Class.forName("com.mysql.jdbc.Driver");，使用这种方式（类加载器），编译期就不会产生依赖，如果我们把pom文件里面的mysql依赖注释掉，也不会立马爆红，但是无法编译。

03IoC 的概念和作用

3.1，什么是工厂模式解耦？

我们把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂，这种方法就称为：工厂模式解耦

3.2，IoC(Inversion Of Control)控制反转

在使用工厂模式解耦的过程中

1，存哪去？
由于我们是很多对象，肯定要找个集合来存。这时候有 Map 和 List 供选择。到底选 Map 还是 List 就看我们有没有查找需求。有查找需求，选 Map。所以我们的答案就是在应用加载时，创建一个 Map，用于存放三层对象。我们把这个 map 称之为容器。
2、什么是工厂？
工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。原来：我们在获取对象时，都是采用 new 的方式（是主动的），现在：我们获取对象时，有工厂为我们查找或者创建对象（是被动的）。
这种被动接收的方式获取对象的思想就是控制反转，它是 spring 框架的核心之一

3.3，IoC 的作用

削减计算机程序的耦合(解除我们代码中的依赖关系）

04使用工厂模式解耦案例演示（Ioc的引出）

IoC控制反转，我们将创建对象的过程交给工厂，在我们需要创建对象的时候由工厂反射来为我们创建对象，控制权转交给工厂（控制反转）
案例要求：账户的业务层和持久层的依赖关系解决。
由于我们并不是真正的要做增删改查操作，所以此时我们没必要写实体类用来封装数据的信息，只需在最后打印一条信息即可

4.1，创建一个maven工程（spring）

由于我们是模拟方式查数据库，并不是真正的查数据库，所以mysql坐标，还有实体类就省略不写了。
也就是我们在这个工程中无需导入额外的包。

4.2，持久层IAccountDao以及AccountDaoImpl.java实现类

IAccountDao

package com.aismall.dao;
/*账户的持久层接口*/
public interface IAccountDao {
    /*模拟保存账户*/
    void saveAccount();
}

AccountDaoImpl.java

package com.aismall.dao.impl;
import com.aismall.dao.IAccountDao;

/**
 * 账户的持久层实现类
 */
public class AccountDaoImpl implements IAccountDao {

    public  void saveAccount(){
        System.out.println("保存了账户");
    }
}

4.3，bean.properties配置文件

用于反射创建对象
key=accountDao
value=com.aismall.dao.impl.AccountDaoImpl
key=accountService
value=com.aismall.service.impl.AccountServiceImpl

accountDao=com.aismall.dao.impl.AccountDaoImpl
accountService=com.aismall.service.impl.AccountServiceImpl

4.4，工厂类BeanFactory.java（重点）

Bean：在计算机英语中，有可重用组件的含义。
JavaBean：用java语言编写的可重用组件
javabean > 实体类（JavaBean不等于实体类）
BeanFactory.java一个创建Bean对象的工厂
它就是创建我们的service和dao对象的。
第一个：需要一个配置文件来配置我们的service和dao
配置的内容：唯一标识=全限定类名（key=value)
第二个：通过读取配置文件中配置的内容，反射创建对象
我的配置文件可以是xml也可以是properties
我们使用properties进行配置

public class BeanFactory {
    //1.定义一个Properties对象（用来读取配置文件）
    private static Properties props;
    //2.定义一个Map,用于存放我们要创建的对象。我们把它称之为容器
    private static Map<String,Object> beans;

    //使用静态代码块为Properties对象赋值
    static {
        try {
            //3.实例化对象
            props = new Properties();
            //4.获取properties文件的流对象，使用类加载器来获取，避免路径问题
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            //5.将配置文件内容加载到Properties对象中
            props.load(in);
            //6.实例化容器
            beans = new HashMap<String,Object>();
            //7.取出配置文件中所有的Key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //8.取出每个Key
                String key = keys.nextElement().toString();
               // System.out.println(key);
                //9.根据key获取value
                String beanPath = props.getProperty(key);
                //System.out.println(beanPath);
                //10.反射创建对象：使用类加载器，把map中的value属性
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch(Exception e){
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }

   /*根据bean的名称获取对象*/
    //注意此处的返回值类型应该是一个Object类型（不能为具体的类型，反射创建的类型不是一个）
    public static Object getBean(String beanName){
        //System.out.println(beans.get("accountService"));
        return beans.get(beanName);
    }    
}

4.5，业务层IAccountService和AccountServiceImpl.java

IAccountService

package com.aismall.service;

/*账户业务层的接口*/
public interface IAccountService {

    /*模拟保存账户*/
    void saveAccount();
}

AccountServiceImpl.java

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
    //使用new关键字创建对象
    //private IAccountDao accountDao = new AccountDaoImpl();
    public void  saveAccount(){
        //使用工厂模式创建对象
        IAccountDao ad = (IAccountDao)BeanFactory.getBean("accountDao");
        ad.saveAccount();
    }
}

4.6，模拟表现层Client.java

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {

    public static void main(String[] args) {
        //使用new关键字创建对象（我们要解决的就是不用new关键字，使用反射创建对象）
        //IAccountService as = new AccountServiceImpl();

        //使用反射创建对象
        IAccountService as = (IAccountService) BeanFactory.getBean("accountService");
        System.out.println(as);
        as.saveAccount();
    }
}

05，使用 spring 的 IOC 解决程序耦合（基于xml配置文件）

案例需求：账户的业务层和持久层的依赖关系解决。
在开始 spring 的配置之前，我们要先准备一下环境。由于我们是使用 spring 解决依赖关系，并不是真正的要做增删改查操作，所以此时我们没必要写实体类用来封装数据的信息，只需在最后打印一条信息即可
其实和上面那个工程所做的功能是一样的，只不过这次使用spring来解决依赖关系，不是使用工厂类

5.1，创建一个maven工程（spring）

导入spring坐标，模拟保存无需实体类和mysql坐标，也不用连接数据库

<packaging>jar</packaging>

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

5.2，持久层IAccountDao以及AccountDaoImpl.java实现类

IAccountDao

public interface IAccountDao {
    /*保存账户的方法*/
    void saveAccount();
}

AccountDaoImpl.java

public class AccountDaoImpl implements IAccountDao {
    public void saveAccount() {
        System.out.println("账户保存了");
    }
}

5.3，beans.xml配置文件（重点）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- bean 标签：用于配置让 spring 创建对象，并且存入 ioc 容器之中
         id 属性：对象的唯一标识。
        class 属性：指定要创建对象的全限定类名
         -->
    <!-- 配置 service -->
    <bean id="accountService" class="com.aismall.service.impl.AccountServiceImpl">
    </bean>
    <!-- 配置 dao -->
    <bean id="accountDao" class="com.aismall.dao.impl.AccountDaoImpl"></bean>
</beans>

5.4，业务层IAccountService和AccountServiceImpl.java实现类

IAccountService

public interface IAccountService {
    /*保存账户方法*/
    void saveAccount();
}

AccountServiceImpl.java

public class AccountServiceImpl implements IAccountService {
    public void saveAccount() {
        //1.获取spring核心容器中的对象
        ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
        //2. //2.根据id获取bean对象
        IAccountDao ao=(IAccountDao)ac.getBean("accountDao");
        ao.saveAccount();
    }
}

5.5，模拟表现层Client.java（重点）

1，获取Spring的ioc核心容器，并根据id获取对象
2，ApplicationContext的三个常用实现类
（IDEA中查看方法）在ApplicationContext上鼠标右键Diagrams—>ShowDiagrams，然后在ApplicationContext上鼠标右键Show Implementations，就可以看到所有的实现类
- 我们在这里介绍三个：
  ClassPathXmlApplicationContext：加载类路径下的配置文件（我们使用这个）
  FileSystemXmlApplicationContext：加载任意路径下的配置文件
  AnnotationConfigApplicationContext：读取注解创建容器
3，核心容器两个接口引发的问题：
- ApplicationContext：（单例模式比较好），他在构建容器时，创建对象采取的策略是采用立即加载的方式，也就是说，只要一读取完配置文件，马上就创建配置文件中配置的对象（可以在无参构造函数中输出语句来查看对象创建与否）
- BeanFactory：（多例模式比较好）他在构建容器时，创建对象的策略是采用延时加载的方式，也就是说，什么时候根据id获取对象，什么时候真正创建对象

**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {
    public static void main(String[] args) {
        //1.获取spring核心容器中的对象
        ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
        //2.根据id获取bean对象
        IAccountService as=(IAccountService)ac.getBean("accountService");
        as.saveAccount();
        //System.out.println(as);
    }
}

06，Spring 基于 XML 的 IOC 细节

当我们把对象的创建交给spring来管理的时候，要注意一下细节

6.1，创建bean的三种方式

第一种方式：使用默认构造函数创建。
在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。
例如：

<bean id="accountService" class="AccountServiceImpl"></bean>

第二种方式：使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）
例如：

<bean id="instanceFactory" class="InstanceFactory"></bean>
<bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>

第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)
例如：

 <bean id="accountService" class="StaticFactory" factory-method="getAccountService"></bean>

注意：默认为单例属性

6.2，bean对象的作用范围

bean的作用范围调整：使用bean标签的scope属性
作用：用于指定bean的作用范围
取值：常用的就是单例的和多例的
singleton：单例的（默认值）
prototype：多例的
request：作用于web应用的请求范围
session：作用于web应用的会话范围
global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session(和负载均衡有关)
init-method：指定类中的初始化方法名称。
destroy-method：指定类中销毁方法名称。
例如：

  <bean id="accountService" class="AccountServiceImpl" scope="prototype"></bean>

6.3，bean对象的生命周期

单例对象
出生：当容器创建时对象出生
活着：只要容器还在，对象一直活着
死亡：容器销毁，对象消亡
总结：单例对象的生命周期和容器相同
多例对象
出生：当我们使用对象时spring框架为我们创建
活着：对象只要是在使用过程中就一直活着。
死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收

6.4，演示：创建Bean 的三种方式，作用范围，生命周期

在这里插入图片描述

6.4.1业务层接口IAccountService和AccountServiceImpl.java

IAccountService

/**
 * 账户业务层的接口
 */
public interface IAccountService {

    /**
     * 模拟保存账户
     */
    void saveAccount();
}

AccountServiceImpl.java

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {

    /*默认构造函数*/
    public AccountServiceImpl(){
        System.out.println("对象创建了");
    }
    /*保存操作方法*/
    public void  saveAccount(){
        System.out.println("service中的saveAccount方法执行了。。。");
    }
    /*初始化操作方法*/
    public void  init(){
        System.out.println("对象初始化了。。。");
    }
    /*销毁操作方法*/
    public void  destroy(){
        System.out.println("对象销毁了。。。");
    }
}

6.4.2 InstanceFactory.java和StaticFactory.java

InstanceFactory.java

/**
 * 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数）
 */
public class InstanceFactory {
    //无空参构造函数（默认构造）
    //有参构造函数
    //第二种：普通方法
    public IAccountService getAccountService()
    {
        return new AccountServiceImpl();
    }
}

StaticFactory.java

/**
 * 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数）
 */
public class StaticFactory {
    //无空参构造函数（默认构造）
    //有参构造函数
    //第三种：静态方法
    public static IAccountService getAccountService(){

        return new AccountServiceImpl();
    }
}

6.4.3 模拟表现层Client.java

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {
    
    public static void main(String[] args) {
        //1.获取核心容器对象
        // ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // ApplicationContext的子类： ClassPathXmlApplicationContext
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取Bean对象
        IAccountService as1  = (IAccountService)ac.getBean("accountService");
        //3.在演示多例模式的时候打开，如果返回false则为多例模式
        //IAccountService as2  = (IAccountService)ac.getBean("accountService");
        //System.out.println(as1==as2);
        as1.saveAccount();

        //手动关闭容器：ClassPathXmlApplicationContext中的方法，父类无法调用
        ac.close();
    }
}

6.4.4 bean.xml配置文件（非常重要）

使用此配置文件说明

先把上面的文件都创建好
beans下的bean标签逐个的打开进行演示
在演示Bean的三种创建方式时，为了模拟出没有默认构造函数的形式，我们在BeanFactory包下创建了两个类
在演示对象的单例多例属性时，在Client.Java中创建两个对象，通过比较来得知对象是单例还是多例
在演示对象的生命周期的时候，为了能看到对象初始化和销毁的时间，我们在AccountServiceImpl.java中创建了两个方法（init和destroy）

<?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的三种方式 -->

    <!-- 第一种方式：使用默认构造函数创建-->
    <!--在默认情况下：它会根据默认无参构造函数来创建类对象。
    如果 bean 中没有默认无参构造函数，将会创建失败。-->
    <!--<bean id="accountService" class="com.aismall.service.impl.AccountServiceImpl"></bean>-->

    <!-- 第二种方式： 使用普通工厂中的方法创建对象-->
    <!-- 此种方式是：
    先把工厂的创建交给 spring 来管理。
    然后在使用工厂的 bean 来调用里面的方法
    factory-bean 属性：用于指定实例工厂 bean 的 id。
    factory-method 属性：用于指定实例工厂中创建对象的方法。
    -->
    <!--<bean id="InstanceFactory" class="com.aismall.factory.InstanceFactory"></bean>
    <bean id="accountService" factory-bean="InstanceFactory" factory-method="getAccountService"></bean>-->

    <!-- 第三种方式：使用工厂中的静态方法创建对象-->
    <!-- 此种方式是:
   使用 StaticFactory 类中的静态方法getAccountService创建对象，并存入 spring 容器
   id 属性：指定 bean 的 id，用于从容器中获取
   class 属性：指定静态工厂的全限定类名
   factory-method 属性：指定生产对象的静态方法
   -->
   <!-- <bean id="accountService" class="com.aismall.factory.StaticFactory" factory-method="getAccountService"></bean>-->

    <!--默认为单例属性-->
    <!--演示：bean对象作用范围-->
    <!--<bean id="accountService" class="AccountServiceImpl" scope="prototype"></bean>-->

	<!--演示：bean对象生命周期-->
    <bean id="accountService" class="com.aismall.service.impl.AccountServiceImpl"
          scope="prototype" init-method="init" destroy-method="destroy"></bean>
</beans>

07，spring 的依赖注入

7.1什么是依赖注入？

依赖注入： Dependency Injection。它是 spring 框架核心 ioc 的具体实现。
我们的程序在编写时，通过控制反转，把对象的创建交给spring来管理，但是代码中不可能出现没有依赖的情况。ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。
简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取

7.2，依赖能够注入的数据类型以及依赖注入的方式

依赖注入能注入的数据：有三类

基本类型和String
其他bean类型（在配置文件中或者注解配置过的bean）
复杂类型/集合类型

依赖注入的方式：有三种

第一种：使用构造函数提供
第二种：使用set方法提供
第三种：使用注解提供

构造函数注入：

前提：类中必须提供有参构造函数

使用的标签:constructor-arg
      标签出现的位置：bean标签的内部
      标签中的属性：
          type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
          index：用于指定要注入的数据，给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
          name：用于指定给构造函数中指定名称的参数赋值（这个最好用）    常用的
          =============以上三个用于指定给构造函数中哪个参数赋值===============================
          value：用于提供基本类型和String类型的数据
          ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

      优势：
          在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
      弊端：
          改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

set方法注入:

前提：类中必须提供属性的set方法

set方法注入是更常用的方式
    涉及的标签：property
    出现的位置：bean标签的内部
    标签的属性
        name：用于指定注入时所调用的set方法名称（例如：setName()只需要把set去掉然后Name变成小写name）
        value：用于提供基本类型和String类型的数据
        ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
    优势：
        创建对象时没有明确的限制，可以直接使用默认构造函数
    弊端：
        如果有某个成员必须有值，则获取对象是有可能set方法没有执行。

set方法注入复杂数据类型

因为set方法注入比较常用所以我们在介绍一下如何使用set方法注入复杂数据类型

复杂类型的注入/集合类型的注入
        用于给List结构集合注入的标签：
            list array set
        用于个Map结构集合注入的标签:
            map  props
注意：结构相同，标签可以互换，也就是结构相同的集合标签可以随意使用
例如：下面这三个都可以使用list标签
<property name="myStrs">
    <set>
         <value>AAA</value>
         <value>BBB</value>
         <value>CCC</value>
     </set>
</property>

<property name="myList">
    <array>
        <value>AAA</value>
        <value>BBB</value>
        <value>CCC</value>
    </array>
</property>

<property name="mySet">
  <list>
      <value>AAA</value>
      <value>BBB</value>
      <value>CCC</value>
  </list>
</property>

7.3，依赖注入演示

为了演示上面提到的三种依赖注入注入的方式（使用构造函数注入，使用set方法注入简单数据类型和复杂数据类型），我们为IAccountServiceDao接口创建了三个实现类用于演示三种注入方法

7.3.1，创建一个maven工程（spring）

导入坐标

 <packaging>jar</packaging>

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

7.3.2，创建IAccountService接口以及三个实现类

IAccountService

/**
 * 账户业务层的接口
 */
public interface IAccountService {

    /**
     * 模拟保存账户
     */
    void saveAccount();
}

AccountServiceImpl

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
    
    //如果是经常变化的数据，并不适用于注入的方式
    private String name;
    private Integer age;
    private Date birthday;

    public AccountServiceImpl(String name,Integer age,Date birthday){
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public void  saveAccount(){
        System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
    }
}

AccountServiceImpl2

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl2 implements IAccountService {

    //如果是经常变化的数据，并不适用于注入的方式
    private String name;
    private Integer age;
    private Date birthday;

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

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public void  saveAccount(){
        System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
    }
}

AccountServiceImpl3

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl3 implements IAccountService {

    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProps;

    public void setMyStrs(String[] myStrs) {
        this.myStrs = myStrs;
    }

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public void setMyProps(Properties myProps) {
        this.myProps = myProps;
    }

    public void  saveAccount(){
        System.out.println(Arrays.toString(myStrs));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myProps);
    }
}

7.3.3，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.xsd">
        
    <!--构造函数注入：AccountServiceImpl类-->
    <bean id="accountService" class="com.aismall.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="泰斯特"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>
    
    <!-- 配置一个日期对象 -->
    <bean id="now" class="java.util.Date"></bean>

    <!-- set方法注入：AccountServiceImpl2类-->
    <bean id="accountService2" class="com.aismall.service.impl.AccountServiceImpl2">
        <property name="name" value="TEST" ></property>
        <property name="age" value="21"></property>
        <property name="birthday" ref="now"></property>
    </bean>

    <!-- 复杂类型的注入/集合类型的注入-->
    <bean id="accountService3" class="com.aismall.service.impl.AccountServiceImpl3">
        <property name="myStrs">
            <set>
                <value>AAA</value>
                <value>BBB</value>
            </set>
        </property>

        <property name="myList">
            <array>
                <value>AAA</value>
                <value>BBB</value>
            </array>
        </property>

        <property name="mySet">
            <list>
                <value>AAA</value>
                <value>BBB</value>
            </list>
        </property>

        <property name="myMap">
            <props>
                <prop key="testA">aaa</prop>
                <prop key="testb">bbb</prop>
            </props>
        </property>

        <property name="myProps">
            <map>
                <entry key="testC" value="CCC"></entry>
                <entry key="testB">
                    <value>BBB</value>
                </entry>
            </map>
        </property>
    </bean>

</beans>

7.3.4 模拟表现层Client.java

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {
    public static void main(String[] args) {
        //1.获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取Bean对象
        //IAccountService as  = (IAccountService)ac.getBean("accountService");
        //as.saveAccount();
        //IAccountService as2  = (IAccountService)ac.getBean("accountService2");
        //as2.saveAccount();
        IAccountService as3  = (IAccountService)ac.getBean("accountService3");
        as3.saveAccount();
    }
}

08，案例：使用 spring 的 IoC 的实现账户的CRUD（纯xml的方式）

在这里插入图片描述

8.1，创建一个maven工程（spring）

依赖坐标

<packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>

        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

    </dependencies>

8.2，IAccountDao接口和AccountDaoImpl.java实现类

IAccountDao

public interface IAccountDao {
    /**
     * 查询所有
     */
    List<Account> findAll();
  }

AccountDaoImpl.java

public class AccountDaoImpl implements IAccountDao {
    private QueryRunner queryRunner;

    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }

    @Override
    public List<Account> findAll() {
        try {
            return queryRunner.query("select * from account",new BeanListHandler<Account>(Account.class));
        } catch (SQLException e) {
            throw  new RuntimeException(e);
        }
    }
}

8.3，实体类Account.java

private Integer id;
private String name;
private  Float money;

8.4IAccountService接口和AccountServiceImpl.java实现类

IAccountService

/**
 * 账户业务层的接口
 */
public interface IAccountService {
    /**
     * 查询所有
     */
    List<Account> findAll();
}

AccountServiceImpl.java

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }
    
    @Override
    public List<Account> findAll() {
        return accountDao.findAll();
    }
}

8.5，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.xsd">

    <!--配置service：AccountServiceImpl-->
    <!--ref类型为Dao的id属性-->
    <bean id="accountService" class="com.aismall.service.impl.AccountServiceImpl">
        <!-- 注入dao：使用set的方式 -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!--配置dao：AccountDaoImpl-->
    <!--ref类型为queryRunner的id属性-->
    <bean id="accountDao" class="com.aismall.dao.impl.AccountDaoImpl">
        <!-- 注入queryRunner：使用set方式 -->
        <property name="queryRunner" ref="queryRunner"></property>
    </bean>

    <!--配置queryRunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源-->
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mySpring"></property>
        <property name="user" value="root"></property>
        <property name="password" value="12345678"></property>
    </bean>

</beans>

8.6，测试类AccountTest.java

public class AccountTest {
    @Test
    public void testFindAll(){
        //1.获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService as=ac.getBean("accountService",IAccountService.class);
        List<Account> accounts= as.findAll();
        for (Account account:accounts) {
            System.out.println(account);
        }
    }
}

spring框架学习笔记01（Ioc+xml）

目录

01spring概述

1.1 spring 是什么?

1.2spring的优势

1.3spring的体系结构

02何为程序的耦合?

2.1使用JDBC进行耦合演示：

2.1.1创建一个maven工程（spring）

2.1.2创建数据库和表

2.1.3在包中编写一个jdbcDemo1.java类

03IoC 的概念和作用

3.1，什么是工厂模式解耦？

3.2，IoC(Inversion Of Control)控制反转

3.3，IoC 的作用

04使用工厂模式解耦案例演示（Ioc的引出）

4.1，创建一个maven工程（spring）

4.2，持久层IAccountDao以及AccountDaoImpl.java实现类

4.3，bean.properties配置文件

4.4，工厂类BeanFactory.java（重点）

4.5，业务层IAccountService和AccountServiceImpl.java

4.6，模拟表现层Client.java

05，使用 spring 的 IOC 解决程序耦合（基于xml配置文件）

5.1，创建一个maven工程（spring）

5.2，持久层IAccountDao以及AccountDaoImpl.java实现类

5.3，beans.xml配置文件（重点）

5.4，业务层IAccountService和AccountServiceImpl.java实现类

5.5，模拟表现层Client.java（重点）

06，Spring 基于 XML 的 IOC 细节

6.1，创建bean的三种方式

6.2，bean对象的作用范围

6.3，bean对象的生命周期

6.4，演示：创建Bean 的三种方式，作用范围，生命周期

6.4.1业务层接口IAccountService和AccountServiceImpl.java

6.4.2 InstanceFactory.java和StaticFactory.java

6.4.3 模拟表现层Client.java

6.4.4 bean.xml配置文件（非常重要）

07，spring 的依赖注入

7.1什么是依赖注入？

7.2，依赖能够注入的数据类型以及依赖注入的方式

7.3，依赖注入演示

7.3.1，创建一个maven工程（spring）

7.3.2，创建IAccountService接口以及三个实现类

7.3.3，bean.xml配置文件

7.3.4 模拟表现层Client.java

08，案例：使用 spring 的 IoC 的实现账户的CRUD（纯xml的方式）

8.1，创建一个maven工程（spring）

8.2，IAccountDao接口和AccountDaoImpl.java实现类

8.3，实体类Account.java

8.4IAccountService接口和AccountServiceImpl.java实现类

8.5，bean.xml配置文件（重点）

8.6，测试类AccountTest.java

猜你喜欢