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中。