目录
Spring框架
IOC:
AOP:
一站式:
spring搭建
Maven 导入 spring 核心基础 jar
编写 spring 配置文件
编写一个 User 实体类
测试 spring
IOC(控制反转)
依赖注入:
1、通过属性注入
2、通过构造方法注入
spring中bean管理
1、基于xml配置方式
2、基于注解方式
添加注解标签:
在一个类中要用到另外的类通过注解标签来自动注入
@Autowired
@Resource
Spring 数据访问层管理
Spring 集成 Mybatis
1、导入 mybatis jar 包
Spring 结合 mybatis 插件包等等
2、配置 sqlSessionFactory
3、指定生成接口代理
4、在 service 中注入 Dao 代理接口,此接口有 Spring 代理实现
Test测试
Spring框架
Spring 是一个轻量级的,IOC 和 AOP 的一站式 Java 开发框架,是为了简化企
业级应用开发而生的。
轻量级:框架体积小(核心模块)
IOC:
即 Inversion of Control(控制反转),缩写为 IOC,是把创建对象的控制权,反转给 Spring 框架管理对象,而非传统实现中由程序代码直接操控。
AOP:
Aspect Oriented Programming (面向切面编程) 。
AOP 是一种编程思想,是面向对象编程(OOP)的一种补充。面向对象编程将程序抽象成各
个层次的对象,而面向切面编程是将程序抽象成各个切面.
将程序中的一些公共的非业务代码分离提取出来,然后在业务代码执行时,给他们横切进来。
使用的动态代理的机制实现,在我们的业务代码,
不显示的调用。在执行业务代码,会由代理对象调用
提交事务的代码。
一站式:
除了核心的IOC和AOP功能之外,还对数据访问层,web层都有封装,所以是一站式框架。
spring搭建
Maven 导入 spring 核心基础 jar
<!-- spring-context -->< dependency >< groupId >org.springframework</ groupId >< artifactId >spring-context</ artifactId >< version >5.2.2.RELEASE</ version ></ dependency >
spring bean 管理
bean对象,由于把对象交给spring管理后,spring会对对象进行
功能的增强,
所以在spring框架中生成的对象,统一称为
bean对象。
区分这个对象是我们自己new的还是spring框架生成的。
编写 spring 配置文件
使用bean标签,配置需要让spring管理的类. id="对象名称,可以在getBean中获得spring生成的对象". class="需要让spring管理的类的地址". scope="配置bean的作用域". scope="singleton"=>单例的(默认) (在spring框架启动时,就创建对象,而且始终只创建了一个对象。) scope="prototype"=>原型的(多例的) 在每次获得对象时,创建一个新的对象.
<?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">
<!--在spring的配置文件注册需要spring框架管理的类-->
<bean id="admin" class="com.ffyc.springpro.model.Admin" scope="singleton" >
</beans>
编写一个 User 实体类
测试 spring
package com.ffyc.springpro.test; import com.ffyc.springpro.model.Admin; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Test1 { public static void main(String[] args) { //Admin admin=new Admin(); ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml"); Admin admin=(Admin) applicationContext.getBean("admin"); Admin admin1=applicationContext.getBean("admin",Admin.class); System.out.println(admin); System.out.println(admin1); } }
IOC(控制反转)
IOC:指的是让spring框架创建对象,创建对象的同时,还有一个动作称为依赖注入。
依赖注入:
依赖注入是指在创建对象的时候,为对象中属性赋值。 依赖注入有两种方式: 1、通过属性注入,(属性的set方法注入) 2、通过构造方法注入
1、通过属性注入
(属性的set方法注入)
<!--通过get,set方法注入--> <property name="account" value="admin"></property> <property name="password" value="1111"></property>
2、通过构造方法注入
<!--通过构造方法注入--> <constructor-arg name="account" value="admin1"></constructor-arg> <constructor-arg name="password" value="1212"></constructor-arg>
spring中bean管理
有两种方式。
1、基于xml配置方式
id="对象名称,可以在getBean中获得spring生成的对象"。
class="需要让spring管理的类的地址"。
scope="配置bean的作用域".。scope="singleton"=>单例的(默认) (在spring框架启动时,就创建对象,而且始终只创建了一个对象。)scope="prototype"=>原型的(多例的) 在每次获得对象时,创建一个新的对象。request: 每次 http 请求都会创建一个 bean, 仅 用 于 WebApplicationContext 环境。
<?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">
<!--在spring的配置文件注册需要spring框架管理的类
使用bean标签,配置需要让spring管理的类
id="对象名称,可以在getBean中获得spring生成的对象"
class="需要让spring管理的类的地址"
scope="配置bean的作用域"
scope="singleton"=>单例的(默认) (在spring框架启动时,就创建对象,而且始终只创建了一个对象。)
scope="prototype"=>原型的(多例的) 在每次获得对象时,创建一个新的对象
IOC:指的是让spring框架创建对象,创建对象的同时,还有一个动作称为依赖注入。
依赖注入:在创建对象的时候,为对象中属性赋值
依赖注入有两种方式:
1、通过属性注入,(属性的set方法注入)
2、通过构造方法注入
-->
<bean id="admin" class="com.ffyc.springpro.model.Admin" scope="singleton" >
<!--通过get,set方法注入-->
<!-- <property name="account" value="admin"></property>-->
<!-- <property name="password" value="1111"></property>-->
<!--通过构造方法注入-->
<constructor-arg name="account" value="admin1"></constructor-arg>
<constructor-arg name="password" value="1212"></constructor-arg>
</bean>
<bean id="adminDao" class="com.ffyc.springpro.dao.AdminDao"></bean>
<bean id="adminService" class="com.ffyc.springpro.service.AdminService">
<!--name="adminDao"拿到是adminService中的属性名对应 ref="adminDao"引用的是id为adminDao的AdminDao中的对象 注入进来 -->
<property name="adminDao" ref="adminDao"></property>
</bean>
</beans>
2、基于注解方式
首先开启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"
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.springpro"> </context:component-scan>
</beans>
添加注解标签:
@Component(value = "admin") @Scope(value = "prototype")不同层用不同的注解标签
@Repository(value = "adminDao") @Service(value = "adminService") @Autowired
package com.ffyc.springpro.model;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
//等同于xml中 <bean id="admin" class="com.ffyc.springpro.model.Admin" scope="singleton" >
@Component(value = "admin")
@Scope(value = "prototype")//scope=""
public class Admin {
private String account;
private String password;
public Admin() {
System.out.println("无参");
}
public Admin(String account, String password) {
this.account = account;
this.password = password;
System.out.println("有参");
}
public String getAccount() {
return account;
}
public void setAccount(String account) {
System.out.println("setAccount");
this.account = account;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
System.out.println("setPassword");
this.password = password;
}
@Override
public String toString() {
return "Admin{" +
"account='" + account + '\'' +
", password='" + password + '\'' +
'}';
}
}
在一个类中要用到另外的类通过注解标签来自动注入
@Autowired
spring注解方式Bean管理,自动注入。 @Autowired 是spring框架提供的注解,用于在属性和属性的set方法上,如果写在属性上,set方法都可以不需要了。 默认情况下,要注入的值不能为空。默认值 :required==true; 自动注入有两种值的匹配方式: 1、通过属性的类型查找 2、通过对象的名字查找 @Qualifier(value = "adminDao")
@Resource
@Resource 是java语言中提供的注解标签 也是添加在属性上,不需要写set方法。 注入的值也不能为空。 可以通过属性的类型查找。 也可以通过对象的名字查找。
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 {
/*
spring注解方式Bean管理 自动注入
@Autowired 是spring框架提供的注解,用于在属性和属性的set方法上,如果写在属性上,set方法都可以不需要了。
默认情况下,要注入的值不能为空。required==true;默认值
自动注入有两种值的匹配方式:
1、通过属性的类型查找
2、通过对象的名字查找
@Qualifier(value = "adminDao")
@Resource 是java语言中提供的注解标签
也是添加在属性上,不需要写set方法。
注入的值也不能为空。
可以通过属性的类型查找。
也可以通过对象的名字查找。
*/
//@Autowired
//@Qualifier(value = "adminDao")
@Resource
//@Resource(name = "adminDao")
AdminDao adminDao;
public void saveAdmin(){
adminDao.saveAdmin();
}
}
Spring 数据访问层管理
Spring 是个一站式框架:Spring 自身也提供了 web 层的 SpringWeb 和 持久层的 Spring JdbcTemplate。
导入包
下载 Spring jdbc 数据访问层 jar 包<!-- spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.2.2.RELEASE</version> </dependency> <!--mysql--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.16</version> </dependency> <!-- 阿里巴巴数据库链接管理组件 专门负责创建数据库链接的操作--> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.10</version> </dependency>
管理数据源对象
<!-- 阿里巴巴数据库连接管理对象,负责生成数据库连接对象,以及提供数据库链接池功能 接下俩让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中对jdbc进行封装的操作类型:
<!-- 配置spring中对jdbc进行封装的操作类型 JdbcTemplate --> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <!--JdbcTemplate定义的属性名--> <property name="dataSource" ref="druidDataSource"></property> </bean>
package com.ffyc.springpro.dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
//不同层使用不同的标签
@Repository//(value = "adminDao")
public class AdminDao {
@Autowired
JdbcTemplate jdbcTemplate;
public void saveAdmin(){
//jdbcTemplate.execute("create table ");//主要实行创建表的ddl语句,没有返回值
jdbcTemplate.update("insert into admin(account,password,gender) values (?,?,?)","张山","11212","女");
}
}
Spring 集成 Mybatis
Spring 集成 Mybatis 其核心是将 SqlSessionFactory 交由 Spring 管理,并由
Spring 管理对 dao 接口的代理实现。
1、导入 mybatis jar 包
Spring 结合 mybatis 插件包等等
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>ssm</artifactId>
<version>1.0-SNAPSHOT</version>
<name>ssm</name>
<packaging>war</packaging>
<properties>
<maven.compiler.target>1.8</maven.compiler.target>
<maven.compiler.source>1.8</maven.compiler.source>
<junit.version>5.6.2</junit.version>
</properties>
<dependencies>
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-web-api</artifactId>
<version>8.0.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<!-- spring-context spring核心jar包-->
<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>
<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.16</version>
</dependency>
<!-- 阿里巴巴数据库链接管理组件 专门负责创建数据库链接的操作-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</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>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.16.10</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>3.3.0</version>
</plugin>
</plugins>
</build>
</project>
2、配置 sqlSessionFactory
3、指定生成接口代理
<?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/LoginDao.xml"><!--扫描mappers映射文件-->
</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 中注入 Dao 代理接口,此接口有 Spring 代理实现
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;
}
}
Test测试
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);
Admin admin=new Admin();
admin.setAccount("admin");
admin.setPassword("111");
Admin admin1=loginService.login(admin);
System.out.println(admin1);
}
}