Spring入门-IOC和XML配置

---

Spring入门

1 Spring简介

1.1 什么是框架

• 源自于建筑学，隶属土木工程，后发展到软件工程领域

• 软件工程框架：经过验证的，具有一定功能的，半成品软件

  • 经过验证

  • 具有一定功能

  • 半成品

1.2 框架的作用

1.3 Spring是什么

Spring是分层的JavaSE/EE应用full-stack轻量级开源框架

1.4 Spring的体系结构

1.5 Spring的发展历史

1.6 Spring容器概念(简单来说就是MAP)

Spring提供了两种容器类型：BeanFactory和ApplicationContext。简单说就是存储id和实现类的键值对来解耦操作.

BeanFactory是基础类型IoC容器，提供完整的IoC服务支持。

如果没有特殊指定，默认采用延迟初始化策略（lazy-load）只有当客户端对象需要访问容器中的某个受管对象的时候，才对该受管对象进行初始化以及依赖注入操作。所以，相对来说，容器启动初期速度较快，所需要的资源有限资源有限，并且功能要求不是很严格的场景，BeanFactory是比较合适的 IoC容器选择

ApplicationContext。ApplicationContext在BeanFactory的基础上构建，是相对比较高 级的容器实现，除了拥有BeanFactory的所有支持，ApplicationContext还提供了其他高级，比如事件发布、国际化信息支持等，。ApplicationContext所管理 的对象，在该类型容器启动之后，默认全部初始化并绑定完成。所以，相对于BeanFactory来说，ApplicationContext要求更多的系统资源，同时，因为在启动时就完成所有初始化，容 器启动时间较之BeanFactory也会长一些。在那些系统资源充足，并且要求更多功能的场景中， ApplicationContext类型的容器是比较合适的选择

2 IoC简介

2.1 优质程序代码的制作原则

2.2 耦合与内聚

• 耦合（Coupling）：代码书写过程中所使用技术的结合紧密度，用于衡量软件中各个模块之间的互联程度

• 内聚（Cohesion）：代码书写过程中单个模块内部各组成部分间的联系，用于衡量软件中各个功能模块内部的功能联系

• 程序书写的目标：高内聚，低耦合
  • 就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却不要那么紧密

2.3 工厂模式发展史

2.4 Spring发展历程

2.5 IoC

• IoC（Inversion Of Control）控制反转，Spring反向控制应用程序所需要使用的外部资源,用于给对象赋予实现类

• Spring控制的资源全部放置在Spring容器中，该容器称为IoC容器

  

3 入门案例

3.1 案例环境说明

• 模拟三层架构中表现层调用业务层功能

  • 表现层：UserApp模拟UserServlet（使用main方法模拟）

  • 业务层：UserService

3.2)IoC入门案例制作步骤

1.导入spring坐标（5.1.9.release）

2.编写业务层与表现层（模拟）接口与实现类

3.建立spring配置文件

4.配置所需资源（Service）为spring控制的资源

5.表现层（App）通过spring获取资源（Service实例）

3.2.1 IoC入门案例制作步骤-1

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>5.1.9.RELEASEversion>
dependency>

3.2.2 IoC入门案例制作步骤-2

public interface UserService {
	//业务方法  
	void save();
}

3.2.3 IoC入门案例制作步骤-3

public class UserServiceImpl implements UserService {
    public void save() {
        System.out.println("user service running...");
    }
}

3.2.4 IoC入门案例制作步骤-4

<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean id="userService" class="com.itoldlu.service.impl.UserServiceImpl"/>
beans>

3.2.5 IoC入门案例制作步骤-5

public class UserApp {
    public static void main(String[] args) {
        //2.加载配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //3.获取资源
        UserService userService = (UserService) ctx.getBean("userService");
        userService.save();
    }
}

4 IoC配置（XML格式）

4.1 bean的定义

Spring 官方文档对 bean 的解释是：

In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by
a Spring IoC container.

翻译过来就是：

在 Spring 中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。bean是一个由Spring
IoC容器实例化、组装和管理的对象。

概念简单明了，我们提取处关键的信息：

bean是对象，一个或者多个不限定
bean由Spring中一个叫IoC的东西管理
我们的应用程序由一个个bean构成

• 名称：bean

• 类型：标签

• 归属：beans标签

• 作用：定义spring中的资源，受此标签定义的资源将受到spring控制

• 格式：

  <beans>
  	<bean />
  beans>
  

• 基本属性：

  <bean id="beanId" name="beanName1,beanName2" class="ClassName">bean>
  

  id：bean的名称，通过id值获取bean

  class：bean的类型

  name：bean的名称，可以通过name值获取bean，用于多人配合时给bean起别名
  

4.2 bean属性scope

• 名称：scope

• 类型：属性

• 归属：bean标签

• 作用：定义bean的作用范围

• 格式：

  <bean scope="singleton">bean>
  

• 取值：

  • singleton：设定创建出的对象保存在spring容器中，是一个单例的对象
  • prototype：设定创建出的对象保存在spring容器中，是一个非单例的对象
  • request、session、application、 websocket ：设定创建出的对象放置在web容器对应的位置

4.3 bean生命周期

• 名称：init-method，destroy-method

• 类型：属性

• 归属：bean标签

• 作用：定义bean对象在初始化或销毁时完成的工作

• 格式：

  bean>
  

• 取值：bean对应的类中对应的具体方法名

• 注意事项：

  • 当scope=“singleton”时，spring容器中有且仅有一个对象，init方法在创建容器时仅执行一次

  • 当scope=“prototype”时，spring容器要创建同一类型的多个对象，init方法在每个对象创建时均执行一次

  • 当scope=“singleton”时，关闭容器会导致bean实例的销毁，调用destroy方法一次

  • 当scope=“prototype”时，对象的销毁由垃圾回收机制gc()控制，destroy方法将不会被执行

4.4 bean对象创建方式（了解）

(1)factory-bean

• 名称：factory-bean

• 类型：属性

• 归属：bean标签

• 作用：定义bean对象创建方式，使用静态工厂的形式创建bean，兼容早期遗留系统的升级工作

• 格式：

  <bean class="FactoryClassName" factory-method="factoryMethodName">bean>
  

• 取值：工厂bean中用于获取对象的静态方法名

• 注意事项：

  • class属性必须配置成静态工厂的类名

(2)factory-bean，factory-method

• 名称：factory-bean，factory-method

• 类型：属性

• 归属：bean标签

• 作用：定义bean对象创建方式，使用实例工厂的形式创建bean，兼容早期遗留系统的升级工作

• 格式：

  <bean factory-bean="factoryBeanId" factory-method="factoryMethodName">bean>
  

• 取值：工厂bean中用于获取对象的实例方法名

• 注意事项：

  • 使用实例工厂创建bean首先需要将实例工厂配置bean，交由spring进行管理

  • factory-bean是实例工厂的beanId

4.5 DI和IOC

IOC:控制反转，就是将对象的创建交由框架管理
DI:依赖注入通过框架给成员变量赋值，有2种方式，set方法和构造方法

4.6 set注入（主流）

• 名称：property

• 类型：标签

• 归属：bean标签

• 作用：使用set方法的形式为bean提供资源

• 格式：

  <bean>
  	<property />
  </bean>
  

• 基本属性：

  <property name="propertyName" value="propertyValue" ref="beanId"/>
  

  name：对应bean中的属性名，要求该属性必须提供可访问的set方法（严格规范为此名称是set方法对应名称）

  value：设定非引用类型属性对应的值，不能与ref同时使用

  ref：设定引用类型属性对应bean的id ，不能与value同时使用

• 注意：一个bean可以有多个property标签

当使用@autowired注解时，你不需要再去写getter和setter方法了，之所以不用写，因为spring注解底层采用java的反射机制。

4.7 构造器注入（了解）

• 名称：constructor-arg

• 类型：标签

• 归属：bean标签

• 作用：使用构造方法的形式为bean提供资源，兼容早期遗留系统的升级工作

• 格式：

  <bean>
  	<constructor-arg />
  bean>
  

• 基本属性：

  <constructor-arg index="arg-index" type="arg-type" ref="beanId"/>
  

  ref：设定引用类型构造方法参数对应bean的id ，不能与value同时使用
  
  type ：设定构造方法参数的类型，用于按类型匹配参数或进行类型校验
  
  index ：设定构造方法参数的位置，用于按位置匹配参数，参数index值从0开始计数
  

  • 注意：一个bean可以有多个constructor-arg标签

  4.8 集合类型数据注入

  • 名称：array，list，set，map，props

  • 类型：标签

  • 归属：property标签 或 constructor-arg标签

  • 作用：注入集合数据类型属性

  • 格式：

    <property>
    	<list>list>
    property>
    

  (1)集合类型数据注入——list

  <property name="al">
      <list>
          <value>itoldluvalue>
          <value>66666value>
      list>
  property>
  

  (2)集合类型数据注入——props

  <property name="properties">
      <props>
          <prop key="name">itoldlu666prop>
          <prop key="value">666666prop>
      props>
  property>
  

  (3)集合类型数据注入——array （了解）

  <property name="arr">
      <array>
          <value>123456value>
          <value>66666value>
      array>
  property>
  

  (4)集合类型数据注入——set（了解）

   <property name="hs">
       <set>
           <value>itoldluvalue>
           <value>66666value>
       set>
  property>
  

  (5)集合类型数据注入——map（了解）

  <property name="hm">
      <map>
          <entry key="name" value="itoldlu66666"/>
          <entry key="value" value="6666666666"/>
      map>
  property>
  

  4.9 使用p命名空间简化配置（了解）

  • 名称：p:propertyName，p:propertyName-ref

  • 类型：属性

  • 归属：bean标签

  • 作用：为bean注入属性值

  • 格式：

    <bean p:propertyName="propertyValue" p:propertyName-ref="beanId"/>
    

  • 注意：使用p命令空间需要先开启spring对p命令空间的的支持，在beans标签中添加对应空间支持

    <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     https://www.springframework.org/schema/beans/spring-beans.xsd">
    

    后续课程中还将开启其他的命名空间，方式同上

  • 案例：

     <bean
           id="userService"
           class="com.itoldlu.service.impl.UserServiceImpl"
           p:userDao-ref="userDao"
           p:bookDao-ref="bookDao"
           />
    

  4.10 SpEL （了解）

  • Spring提供了对EL表达式的支持，统一属性注入格式

  • 类型：属性值

  • 归属：value属性值

  • 作用：为bean注入属性值

  • 格式：

    <property value="EL">bean>
    

  • 注意：所有属性值不区分是否引用类型，统一使用value赋值

  • 所有格式统一使用 value=“********”

    • 常量 #{10} #{3.14} #{2e5} #{‘oldlu’}

    • 引用bean #{beanId}

    • 引用bean属性 #{beanId.propertyName}

    • 引用bean方法 beanId.methodName().method2()

    • 引用静态方法 T(java.lang.Math).PI

    • 运算符支持 #{3 lt 4 == 4 ge 3}

    • 正则表达式支持 #{user.name matches‘[a-z]{6,}’}

    • 集合支持 #{likes[3]}

  • 案例：

     <bean id="userService" class="com.itoldlu.service.impl.UserServiceImpl">
         <property name="userDao" value="#{userDao}"/>
         <property name="bookDao" value="#{bookDao}"/>
         <property name="num" value="#{666666666}"/>
         <property name="version" value="#{'oldlu'}"/>
    bean>
    

  4.11 properties文件

  • Spring提供了读取外部properties文件的机制，使用读取到的数据为bean的属性赋值

  • 操作步骤

    1.准备外部properties文件

    2.开启context命名空间支持

    xmlns:context="http://www.springframework.org/schema/context"
    

      3.加载指定的properties文件
    

  <context:property-placeholder location="classpath:filename.properties">
  

  	4.使用加载的数据
  

  <property name="propertyName" value="${propertiesName}"/>
  

  • 注意：如果需要加载所有的properties文件，可以使用*.properties表示加载所有的properties文件

  • 注意：读取数据使用**${propertiesName}格式进行，其中propertiesName**指properties文件中的属性名

  4.12 团队开发

  • 名称：import

  • 类型：标签

  • 归属：beans标签

  • 作用：在当前配置文件中导入其他配置文件中的项

  • 格式：

    <beans>
        <import />
    beans>
    

  • 基本属性：

    resource：加载的配置文件名

  • Spring容器加载多个配置文件

    new ClassPathXmlApplicationContext("config1.xml","config2.xml");
    

  • Spring容器中的bean定义冲突问题

    • 同id的bean，后定义的覆盖先定义的

    • 导入配置文件可以理解为将导入的配置文件复制粘贴到对应位置

    • 导入配置文件的顺序与位置不同可能会导致最终程序运行结果不同

  4.13 ApplicationContext

  1.ApplicationContext是一个接口，提供了访问spring容器的API

  2.ClassPathXmlApplicationContext是一个类，实现了上述功能

  3.ApplicationContext的顶层接口是BeanFactory

  4.BeanFactory定义了bean相关的最基本操作

  5.ApplicationContext在BeanFactory基础上追加了若干新功能

  对比BeanFactory

  1.BeanFactory创建的bean采用延迟加载形式，使用才创建

  2.ApplicationContext创建的bean默认采用立即加载形式

  FileSystemXmlApplicationContext

  可以加载文件系统中任意位置的配置文件，而ClassPathXmlApplicationContext只能加载类路径下的配置文件

  

  BeanFactory

  Resource res = new ClassPathResource("applicationContext.xml");
  BeanFactory bf = new XmlBeanFactory(res);
  UserService userService = (UserService)bf.getBean("userService");
  

  4.14 第三方资源配置

  • 阿里数据源方案Druid

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver">property>
        <property name="url" value="jdbc:mysql://localhost:3306/spring_ioc">property>
        <property name="username" value="root">property>
        <property name="password" value="root">property>
    bean>
    
    

  5 配置数据库连接池相关知识点

  5.1 作用

  减少频繁创建、频繁释放链接、提高效率

  5.2 常见的连接池

  DBCP，C3P0，Druid

  5.3 创建连接池

  5.3.1 导入spring、数据库和连接池依赖

  <dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>5.1.32version>
  dependency>
  <dependency>
      <groupId>c3p0groupId>
      <artifactId>c3p0artifactId>
      <version>0.9.1.2version>
  dependency>
  <dependency>
      <groupId>com.alibabagroupId>
      <artifactId>druidartifactId>
      <version>1.1.10version>
  dependency>
  <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>5.0.5.RELEASEversion>
  dependency>
  

  5.3.2 创建C3p0连接池

  Java

  @Test
  //测试手动创建 c3p0 数据源
  public void test1() throws Exception {
      ComboPooledDataSource dataSource = new ComboPooledDataSource();
      dataSource.setDriverClass("com.mysql.jdbc.Driver");
      dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
      dataSource.setUser("root");
      dataSource.setPassword("root");
      Connection connection = dataSource.getConnection();
      System.out.println(connection);
      connection.close();
  }
  

  思考

  如何把ComboPooledDataSource对象的创建交给Spring

  5.3.3 创建Druid连接池

  Java

  @Test
  //测试手动创建 druid 数据源
  public void test2() throws Exception {
      DruidDataSource dataSource = new DruidDataSource();
      dataSource.setDriverClassName("com.mysql.jdbc.Driver");
      dataSource.setUrl("jdbc:mysql://localhost:3306/test");
      dataSource.setUsername("root");
      dataSource.setPassword("root");
      DruidPooledConnection connection = dataSource.getConnection();
      System.out.println(connection);
      connection.close();
  }
  

  思考

  如何把DruidDataSource对象的创建交给Spring

  6 Spring管理连接池步骤

  6.1 添加spring、数据库和连接池依赖

  <dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>5.1.32version>
  dependency>
  <dependency>
      <groupId>c3p0groupId>
      <artifactId>c3p0artifactId>
      <version>0.9.1.2version>
  dependency>
  <dependency>
      <groupId>com.alibabagroupId>
      <artifactId>druidartifactId>
      <version>1.1.10version>
  dependency>
  <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>5.0.5.RELEASEversion>
  dependency>
  

  6.2 添加jdbc.properties

  注意：key的值必须要写前缀,不然可能解析不了

  jdbc.driver=com.mysql.jdbc.Driver
  jdbc.url=jdbc:mysql://localhost:3306/test
  jdbc.username=root
  jdbc.password=root
  

  6.3 在spring配置中引入jdbc.properties

  注意：必须先引入context命名空间

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

  6.4 在spring配置中添加连接池配置信息

  
  <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.mchange.v2.c3p0.ComboPooledDataSource">
          <property name="driverClass" value="${jdbc.driver}"/>
          <property name="jdbcUrl" value="${jdbc.url}"/>
          <property name="user" value="${jdbc.username}"/>
          <property name="password" value="${jdbc.password}"/>
      bean>
  
  beans>
  

  测试

  package cn.oldlu;
  
  import com.alibaba.druid.pool.DruidDataSource;
  import com.mchange.v2.c3p0.ComboPooledDataSource;
  import org.junit.Test;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  import javax.sql.DataSource;
  import java.sql.Connection;
  
  public class C3p0Test {
      @Test
      public void test1() throws Exception {
          ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
          DataSource dataSource = (DataSource)context.getBean("dataSource");
          Connection connection = dataSource.getConnection();
          System.out.println(connection);
          connection.close();
      }
  }
  

  7 案例介绍

  使用spring整合mybatis技术，完成账户模块（Account）的基础增删改查功能

  表结构如下

  列名	类型
  id	int	主键、自增
  name	varchar(24)	姓名,字符串，最多24个字符
  money	double(10,2)	账户余额,最大值99999999.99。小数点前最多8位，小数点后最多2位。本案例使用double类型，实际开发中使用decimal(10,2)

  8 XML方式整合

  8.1第一步 引入依赖

  需要引入mysql,mybatis,spring,druid连接池,以及整合mybatis和spring的依赖

  <dependencies>
      
      <dependency>
          <groupId>org.projectlombokgroupId>
          <artifactId>lombokartifactId>
          <version>1.18.4version>
      dependency>
      
      <dependency>
          <groupId>org.springframeworkgroupId>
          <artifactId>spring-contextartifactId>
          <version>5.0.5.RELEASEversion>
      dependency>
      
      <dependency>
          <groupId>org.springframeworkgroupId>
          <artifactId>spring-testartifactId>
          <version>5.0.5.RELEASEversion>
      dependency>
      
      <dependency>
          <groupId>org.aspectjgroupId>
          <artifactId>aspectjweaverartifactId>
          <version>1.8.13version>
      dependency>
      
      <dependency>
          <groupId>org.springframeworkgroupId>
          <artifactId>spring-txartifactId>
          <version>5.0.5.RELEASEversion>
      dependency>
      
      <dependency>
          <groupId>org.mybatisgroupId>
          <artifactId>mybatisartifactId>
          <version>3.5.3version>
      dependency>
      
      <dependency>
          <groupId>mysqlgroupId>
          <artifactId>mysql-connector-javaartifactId>
          <version>5.1.46version>
      dependency>
      
      <dependency>
          <groupId>org.springframeworkgroupId>
          <artifactId>spring-jdbcartifactId>
          <version>5.1.6.RELEASEversion>
      dependency>
      
      <dependency>
          <groupId>com.alibabagroupId>
          <artifactId>druidartifactId>
          <version>1.1.21version>
      dependency>
      
      <dependency>
          <groupId>org.mybatisgroupId>
          <artifactId>mybatis-springartifactId>
          <version>1.3.0version>
      dependency>
      
      <dependency>
          <groupId>junitgroupId>
          <artifactId>junitartifactId>
          <version>4.12version>
          <scope>testscope>
      dependency>
  dependencies>
  

  8.2 第二步 创建数据库

  /*
  SQLyog Ultimate v12.09 (64 bit)
  MySQL - 5.5.40 : Database - spring01
  *********************************************************************
  */
  
  
  /*!40101 SET NAMES utf8 */;
  
  /*!40101 SET SQL_MODE=''*/;
  
  /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
  /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
  /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
  /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
  CREATE DATABASE /*!32312 IF NOT EXISTS*/`spring01` /*!40100 DEFAULT CHARACTER SET utf8 */;
  
  USE `spring01`;
  
  /*Table structure for table `account` */
  
  DROP TABLE IF EXISTS `account`;
  
  CREATE TABLE `account` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `name` varchar(24) DEFAULT NULL,
    `money` double(10,2) DEFAULT NULL,
    PRIMARY KEY (`id`)
  ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
  
  /*Data for the table `account` */
  
  insert  into `account`(`id`,`name`,`money`) values (1,'jack',1000.00),(2,'tom',1000.00),(3,'rose',1000.00);
  
  /*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
  /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
  /*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
  /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
  

  8.3 第三步 创建dao\service\domain

  创建实体类 Account

  package cn.oldlu.domain;
  
  import lombok.AllArgsConstructor;
  import lombok.Data;
  import lombok.NoArgsConstructor;
  
  @Data
  @AllArgsConstructor
  @NoArgsConstructor
  public class Account {
      private Integer id;
      private String name;
      private Double money;
  }
  

  创建 Dao

  package cn.oldlu.dao;
  
  import cn.oldlu.domain.Account;
  
  import java.util.List;
  
  public interface AccountDao {
      List<Account> findAll();
  }
  

  创建Service

  package cn.oldlu.service;
  
  import cn.oldlu.domain.Account;
  
  import java.util.List;
  
  public interface AccountService {
      List<Account> findAll() ;
  }
  

  创建Service实现类

  package cn.oldlu.service.impl;
  
  import cn.oldlu.dao.AccountDao;
  import cn.oldlu.domain.Account;
  import cn.oldlu.service.AccountService;
  import lombok.AllArgsConstructor;
  import lombok.Data;
  import lombok.NoArgsConstructor;
  
  import java.util.List;
  
  
  public class AccountServiceImpl implements AccountService {
      private AccountDao accountDao;
  
      public List<Account> findAll() {
          return accountDao.findAll();
      }
  
      public AccountDao getAccountDao() {
          return accountDao;
      }
  
      public void setAccountDao(AccountDao accountDao) {
          this.accountDao = accountDao;
      }
  }
  

  8.4 第四步 创建jdbc.properties

  Properties

  jdbc.driver=com.mysql.jdbc.Driver
  jdbc.url=jdbc:mysql://localhost:3306/spring01
  jdbc.username=root
  jdbc.password=root
  

  8.5 第五步 创建mapper映射文件

  映射文件的编写必须遵循下面两个原则：

  1. 该映射文件必须和dao在相同的目录(包)下,比如接口在src/cn/oldlu/dao目录下，那么配置文件也必须在resource/cn/oldlu/dao目录下。
  2. 配置文件的名字和dao接口名保持一致,这里叫AccountDao.xml。比如接口叫AccountDao.java,那么配置文件的名字必须叫AccountDao.xml

  
  DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="cn.oldlu.dao.AccountDao">
      
      <select id="findAll" resultType="account">
          select * from account
      select>
  mapper>
  

  8.6 第六步 创建 spring主配置文件

  主配置文件名叫applicationContext.xml

  
  <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"
         xmlns:tx="http://www.springframework.org/schema/tx"
         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
                             http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
  ">
      
      <context:property-placeholder location="classpath:jdbc.properties">context:property-placeholder>
      <bean id="ds" class="com.alibaba.druid.pool.DruidDataSource">
          <property name="driverClassName" value="${jdbc.driver}">property>
          <property name="url" value="${jdbc.url}">property>
          <property name="username" value="${jdbc.username}">property>
          <property name="password" value="${jdbc.password}">property>
      bean>
  
      
      <bean class="org.mybatis.spring.SqlSessionFactoryBean">
          
          <property name="dataSource" ref="ds">property>
          
          <property name="typeAliasesPackage" value="cn.oldlu.domain">property>
      bean>
  
      
      <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
          
         <property name="basePackage" value="cn.oldlu.dao">property> 
      bean>
  
      
      <bean class="cn.oldlu.service.impl.AccountServiceImpl">
          <property name="accountDao" ref="accountDao">property>
      bean>
  beans>
  

  

  8.7 第七步 创建测试类

  public class App {
      public static void main(String[] args) {
          ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
          AccountService accountService = classPathXmlApplicationContext.getBean(AccountService.class);
          List<Account> all = accountService.findAll();
          System.out.println(all);
      }
  }
  

  9 总结

  spring报错从后往前看找自己写的错误,如果都没就是配置文件问题