spring框架搭建、注解方式，数据访问层管理包括JdbcTemplate的使用和spring集成MyBatis框架

spring是什么？

spring是一个轻量级的IOC和AOP的一站式Java开发框架，简化企业级开发

轻量级：框架体积小（核心模块）

IOC：Inversion of Control 控制反转，把创建对象的控制权，反转给spring框架

以前我们在程序中需要对象都是自己new，列如 new StudentDao对象

AOP：Aspect Oriented Programming 面向切面编程

            将程序中的一些公共的非业务代码分离提取出来，然后在业务代码执行时，给他们横切进来。底层使用的是动态代理的机制实现，在我们的业务代码不显示的调用，但是执行业务代码，会通过代理对象，调用非业务代码

一站式：除了核心的IOC和AOP功能之外，还对数据访问层，web层都有封装，所以是一站式

Spring Hello world 搭建

1、创建一个Maven工程，导入spring核心基础jar依赖

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

2、在resources下配置spring.xml

       在spring的配置文件中注册需要spring需要管理的类 使用bean标签，配置需要管理的类 id="对象名称"，可以在getBean中获得spring生成的对象 class="让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">


    <bean id="admin" class="com.ffyc.springpro.model.Admin"></bean>
    
</beans>

3、测试

 

ApplicationContext applicationContext= new ClassPathXmlApplicationContext("spring.xml");

         Admin admin= (Admin)applicationContext.getBean("admin");//不知道返回类型，则返回Object类型

         Admin admin1= applicationContext.getBean("admin",Admin.class);//指定返回Admin类型

        System.out.println(admin);
        System.out.println(admin1);

 spring bean管理

          bean对象，由于把对象交给spring管理后，spring会对对象功能的增强，所以在spring框架中生成的对象，统一称为bean对象。

区分这个对象是我们自己new的还是spring框架生成的。

spring 中bean管理有俩种方式

1、基于xml配置方式

在xml文件中使用bean标签

<bean id="admin" class="com.ffyc.springpro.model.Admin" scope="prototype"></bean>

 bean中scope的俩个元素singleton和prototype

scope="配置bean的作用域"，

1、scope="singleton"默认值， 单例的，在spring框架启动时，创建对象，而且始终创建一个对象

<bean id="admin" class="com.ffyc.springpro.model.Admin" scope="singleton"></bean>

 在spring框架启动时，对象就创建了，所以admin和admin1是同一个对象

ApplicationContext applicationContext= new ClassPathXmlApplicationContext("spring.xml");

 Admin admin= (Admin)applicationContext.getBean("admin");//不知道返回类型，则返回Object类型

 Admin admin1= applicationContext.getBean("admin",Admin.class);//指定返回Admin类型

System.out.println(admin);
System.out.println(admin1);

2、 scope="prototype" 多例的，在每一次获得对象时，创建一个新的对象

<bean id="admin" class="com.ffyc.springpro.model.Admin" scope="prototype"></bean>

每getBean一次就会创建一个对象 

ApplicationContext applicationContext= new ClassPathXmlApplicationContext("spring.xml");

 Admin admin= (Admin)applicationContext.getBean("admin");//不知道返回类型，则返回Object类型

 Admin admin1= applicationContext.getBean("admin",Admin.class);//指定返回Admin类型

System.out.println(admin);
System.out.println(admin1);

 

xml配置方式依赖注入

1、属性注入，属性set方法注入

<bean id="admin" class="com.ffyc.springpro.model.Admin" scope="prototype">
    <property name="account" value="admin"></property>
    <property name="password" value="111"></property>
</bean>

2、构造方法注入 

<bean id="admin" class="com.ffyc.springpro.model.Admin" scope="prototype">
   <constructor-arg name="account" value="admin"></constructor-arg>
    <constructor-arg name="password" value="111"></constructor-arg>
</bean>

2、基于注解方式

开启注解扫描，在配置文件下

< context :component-scan base-package ="包名" > </ context :component-scan >

@Component(value=“user”) 等同于 <bean id=“user” class=“”></bean>

不同层用不同的注解标签来注解对象

Dao层：（数据访问层）

@Repository(value = "adminDao")

service层：（服务层）

@Service(value = "adminService")

model层：（模型层）

@Component(value = "admin")

注解类是原型还是单例

@Scope(value=“prototype”) 原型

@Scope(value=“ singleton ”) 单例

注解方式注入

@Autowired，添加在属性上，自动注入，前提是改属性的类必须加入到spring的管理中，在这个标签小，该属性不需要写get、set方法。

@Autowired 是spring框架提供的注解， 用于在属性和属性的set方法上，如果写在属性上，可以不用写get、set方法 ,默认情况下，注入的值不能为空 默认情况下require=true

@Autowired(require=true) 
AdminDao adminDao;

自动注入有俩种值的匹配方式：

1、通过属性的类型查找，会自己查找AdminDao类，

@Autowired  
AdminDao adminDao;

2、通过对象的名字查找,还要用到  @Qualifier(value = "adminDao")

@Autowired  
@Qualifier(value = "adminDao")
AdminDao adminDao;

java也提供了自动注入@Resource，和@Autowired一样也是有俩种值匹配方式，同时注入的值不能为空

1、通过属性类型查找

@Resource//java提供的自动注入，类型查找
AdminDao adminDao;

2、通过对象的名字查找

 @Resource(name = "adminDao")//java提供的自动注入，对象名查找
AdminDao adminDao;

Spring数据访问层管理

一、JdbcTemplate的使用

目前不在使用，而是作为一个了解 

spring是一站式框架，spring自身也提供了web层的springweb和持久层的JdbcTemplate

开发步骤：

1、导入spring jdbc的jar

<!-- spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

同时也导入阿里数据源（数据库连接管理组件）

<!-- 阿里数据源  数据库管理连接组件-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

2、在spring配置文件中写入：

<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://127.0.0.1:3306/ssmdb?serverTimezone=Asia/Shanghai"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
    <property name="initialSize" value="10"></property><!--初始化连接数量-->
    <property name="maxActive" value="20"></property><!--最大连接数量-->
</bean>

阿里巴巴数据库连接管理对象，负责生成数据库连接对象，已经提供数据库连接池功能 让spring管理阿里巴巴数据库连接对象

<!--
来配置spring中对jdbc进行封装的操作类型 JdbcTemplate
-->
<bean class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="druidDataSource"></property>
</bean>

3、写一个示例查询数据库

创建一个Admin类

package com.ffyc.springpro.model;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;



@Component(value = "admin")//等同于 <bean id=“user” class=“”></bean>
@Scope(value = "prototype") //原型的
public class Admin {
    private String account;
    private String password;

    public Admin() {
        System.out.println("Admin 无参构造");

    }

    public Admin(String account, String password) {
        this.account = account;
        this.password = password;
        System.out.println("Admin有参构造");
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
        System.out.println("setAccount");
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
        System.out.println("setPassword");
    }

    @Override
    public String toString() {
        return "Admin{" +
                "account='" + account + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

Dao层：

package com.ffyc.springpro.Dao;

import com.ffyc.springpro.model.Admin;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

@Repository(value = "adminDao")
public class AdminDao {

    @Autowired
    JdbcTemplate jdbcTemplate;//交给spring框架来创建JdbcTemplate对象
    public void saveAdmin(){

       // jdbcTemplate.execute("");//主要执行创建表DDL,没有返回值
        List<Admin> list=jdbcTemplate.query("select * from admin", new RowMapper<Admin>() {
            public Admin mapRow(ResultSet resultSet, int i) throws SQLException {
                Admin admin=new Admin();
                admin.setAccount(resultSet.getString("account"));
                admin.setPassword(resultSet.getString("password"));
                return admin;
            }
        });
        System.out.println(list);
    }
}

service层

package com.ffyc.springpro.service;

import com.ffyc.springpro.Dao.AdminDao;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service(value = "adminService")
public class AdminService {
     @Resource(name = "adminDao")//java提供的自动注入，对象名查找
    AdminDao adminDao;
    public void saveAdmin(){

        //创建对象交给spring框架
        adminDao.saveAdmin();
    }

    public AdminDao getAdminDao() {
        return adminDao;
    }

    public void setAdminDao(AdminDao adminDao) {
        this.adminDao = adminDao;
    }
}

测试

package com.ffyc.springpro.test;

import com.ffyc.springpro.service.AdminService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test2 {
    public static void main(String[] args) {
        


        ApplicationContext applicationContext= new ClassPathXmlApplicationContext("spring.xml");
        AdminService adminService=  applicationContext.getBean("adminService",AdminService.class);
                     adminService.saveAdmin();
    }
}

结果

这就是Spring 自身也提供了 web 层的 SpringWeb 和 持 久层的 Spring JdbcTemplate。

但是现在已经不用JdbcTemplate，而是spring集成mybatis

spring集成mybatis

spring集成mybatis的核心是将SqlSessionFactory交给spring管理，并由spring管理实现对dao层接口代理的实现。

导入Spring 结合 mybatis 插件包，同时导入mybatis的jar包

<!--Spring 结合 mybatis 插件包-->
 <dependency>
     <groupId>org.mybatis</groupId>
     <artifactId>mybatis-spring</artifactId>
     <version>1.3.1</version>
 </dependency>

<!--mybatis-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.2</version>
</dependency>

先对mybatis进行一个搭建

1、配置mybatis核心文件，

 mybatis配置文件，在mybatis配置文件中不在需要对数据库连接进行配置，在spring.xml中进行配置。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!--mybatis核心全局配置文件-->
<configuration>
    <settings>
        <!--配置日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!--开启驼峰命名自动映射-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
    <!--为类配置别名-->
    <typeAliases>
        <package name="com.ffyc.ssm.model"/>
    </typeAliases>




</configuration>

2、在dao层定义接口，配置dao层相应的映射文件

package com.ffyc.ssm.dao;

import com.ffyc.ssm.model.Admin;
import org.springframework.stereotype.Repository;


public interface LoginDao {
    Admin login(Admin admin);
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">


<mapper namespace="com.ffyc.ssm.dao.LoginDao">

    <select id="login" resultType="Admin">
        select * from admin where account=#{account} and password=#{password}
    </select>
</mapper>

3、配置spring.xml文件

spring.xml配置文件，在spring.xml配置文件中

1、配置SqlSessionFactory，交给spring管理。

2、指定生成dao包下所有接口的代理对象，有了接口代理对象后，则不需要在dao包下进行注入，

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

    <!--开启spring注解扫描功能   指定扫描的包-->
    <context:component-scan base-package="com.ffyc.ssm"> </context:component-scan>

    <!--
    阿里巴巴数据库连接管理对象，负责生成数据库连接对象，已经提供数据库连接池功能
    让spring管理阿里巴巴数据库连接对象
    -->

    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/ssmdb?serverTimezone=Asia/Shanghai"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
        <property name="initialSize" value="10"></property><!--初始化连接数量-->
        <property name="maxActive" value="20"></property><!--最大连接数量-->
    </bean>

    <!--spring管理生成sqlSessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="druidDataSource"></property><!--注入数据源-->
        <property name="configLocation" value="classpath:mybatis.xml"></property><!--mybatis核心配置文件-->
        <property name="mapperLocations" value="classpath:mappers/*Mapper.xml"><!--扫描Mapper下的映射文件-->
        </property>
    </bean>


<!--生成dao包下所有接口的代理对象-->
    <bean id="mapperFactory" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.ffyc.ssm.dao"></property><!--指定接口所在的包-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory">
        </property>
    </bean>

</beans>

4、service层

这里要对注入loginDao属性，spring框架生成dao包下所有接口的代理对象（我们在spring.xml文件中进行了配置）

package com.ffyc.ssm.service;

import com.ffyc.ssm.dao.LoginDao;
import com.ffyc.ssm.model.Admin;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LoginService {
    @Autowired
   LoginDao loginDao;
    public Admin login(Admin admin){
        Admin admin1= loginDao.login(admin);
        return  admin1;
    }
}

5、测试

package com.ffyc.ssm.test;

import com.ffyc.ssm.model.Admin;
import com.ffyc.ssm.service.LoginService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext= new ClassPathXmlApplicationContext("spring.xml");
        LoginService loginService= applicationContext.getBean("loginService",LoginService.class);//拿到LoginService对象
        Admin admin=new Admin();
        admin.setAccount("admin");
        admin.setPassword("111");
        loginService.login(admin);


    }
}

结果，成功打印出来查询的结果

 spring集成mybatis的流程

1、导入相关jar包

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

        <!-- spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

        <!-- 阿里数据源  数据库管理连接组件-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.2</version>
        </dependency>

       <!--Spring 结合 mybatis 插件包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>

2、搭建mybatis框架，配置mybatis核心文件，在配置mybatis核心文件中不对数据库连接进行配置

定义接口，相应xml映射文件等等相关流程。

3、搭建spring框架，配置spring文件，在配置spring文件中配置数据源，spring管理数据源对象

<!--
阿里巴巴数据库连接管理对象，负责生成数据库连接对象，已经提供数据库连接池功能
让spring管理阿里巴巴数据库连接对象
-->

<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://127.0.0.1:3306/ssmdb?serverTimezone=Asia/Shanghai"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
    <property name="initialSize" value="10"></property><!--初始化连接数量-->
    <property name="maxActive" value="20"></property><!--最大连接数量-->
</bean>

核心是SqlSessionFactory交给spring管理，

<!--spring管理生成sqlSessionFactory对象-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="druidDataSource"></property><!--注入数据源-->
    <property name="configLocation" value="classpath:mybatis.xml"></property><!--mybatis核心配置文件-->
    <property name="mapperLocations" value="classpath:mappers/*Mapper.xml"><!--扫描Mapper下的映射文件-->
    </property>
</bean>

生成dao包下所有接口的代理对象

<!--spring管理生成sqlSessionFactory对象-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="druidDataSource"></property><!--注入数据源-->
    <property name="configLocation" value="classpath:mybatis.xml"></property><!--mybatis核心配置文件-->
    <property name="mapperLocations" value="classpath:mappers/*Mapper.xml"><!--扫描Mapper下的映射文件-->
    </property>
</bean>

对dao类型的属性注入，而dao的类不需要进行注入，因为spring生成了接口代理对象在spring.xml中。