Spring入门
Spring框架概述
Spring 框架是一个分层的、面向切面的 Java 应用程序的一站式轻量级解决方案，它是 Spring 技术栈的核心和基础，是为了解决企业级应用开发的复杂性而创建的。简言之：使现有技术更加容易使用，并对其他的开源框架的使用提供支持。如：SSH（全自动框架）SSM（半自动）框架都以spring为中心进行整合。
使用需要的依赖
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.3.21</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.21</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.3.21</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>5.3.21</version>
</dependency>
IOC
控制反转概念
- 是面向对象编程的一种设计模式，把对象创建和对象之间的调用过程 交给spring进行管理
- 目的：降低耦合度
IOC底层原理
xml解析、工厂模式、反射
过程：
- xml配置文件 配置创建的对象
<bean id="dao" class="com.kk.UserDao></bean> - 创建工厂
class UserFactory{ public static UserDao getDao(){ String classValue = class //通过xml解析获得 Class clazz = Class.forName(classValue);//通创反射创建对象 return (UserDao)clazz.newInstance(); } }
IOC(接口)
IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
spring提供IOC容器实现两种方式：(两个接口)
两者都能加载配置文件 获取配置创建对象
-
BeanFactory：IOC容器基本实现 是spring内部的使用接口 不提供开发人员进行使用
加载配置文件时不会创建 获取对象时才创建对象 -
ApplicationContext：BeanFactory接口的子接口 功能更加强大 一般由开发人员进行使用
在加载配置文件时就创建对象（较常用）
IOC操作Bean管理
管理的两种方式：xml方式、注解方式
管理形式：spring创建对象、spring注入属性
基于xml方式实现
创建对象：
创建对象时 默认执行无参构造方法完成对象创建
<bean id="user" class="com.kk.User"></bean>
注入属性：
DI：依赖注入
常用方法注入 使用set、使用有参构造
1. 使用配置文件注入 默认调用set方法注入
<bean id="user" class="com.kk.User">
<property name="name" value="wlk"></property>
</bean>
public class Test_ {
public static void main(String[] args) {
//1.加载spring配置文件
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//2.获取配置创建的对象
User user = context.getBean("user", User.class);
System.out.println(user.getName());
}
}
1.2 p名称空间注入
本质上也是set方式注入 仅仅只是简化了上面的方法
前提：在配置文件头部导入 xmlns:p=“http://www.springframework.org/schema/p”
<bean id="user" class="com.kk.User" p:name="wlk" p:age="19"></bean>
2. 使用有参构造进行注入
前提：需要存在有参构造器
使用constructor-arg标签表示使用有参构造器配置参数
<bean id="user" class="com.kk.User">
<constructor-arg name="name" value="wkk"/>
<constructor-arg name="age" value="18"/>
</bean>
小细节：
想要设置空值使用标签
<bean id="user" class="com.kk.User">
<property name="name"><null/></property>
</bean>
不使用转意字符输出符号
<bean id="user" class="com.kk.User">
<property name="name">
<value>
<![CDATA[ <<<<<<符号>>>>>> ]]>
</value>
</property>
</bean>
注入外部bean
使用情况：当创建对象时 内部需要创建外部的一个对象时
模拟情况
public class UserService {
public void add(){
System.out.println("service add...");
//准备使用bean对该地方进行创建对象
UserDao userDao = new UserDaoImpl();
userDao.update();
}
}
创建UserDao类型属性 生成set方法
创建一个bean 表示创建一个其他类(此处时UserDao)，在本类中的bean下设置property的ref为该bean的id表示在本类中创建一个其他类
<bean id="userService" class="com.kk.service.UserService">
<property name="userDao" ref="userDaoImpl">property>
bean>
<bean id="userDaoImpl" class="com.kk.dao.UserDaoImpl">bean>
public class UserService {
//创建UserDao类型属性 生成set方法
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add(){
System.out.println("service add...");
userDao.update();
}
@Test
public void test(){
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
UserService userService = context.getBean("userService", this.getClass());
userService.add();
}
}
注入属性——内部bean和级联赋值
引入：数据库一对多关系
部门department 员工employment
bean对象
public class Department {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
@Override
public String toString() {
return "Department{" +
"dname='" + dname + '\'' +
'}';
}
}
public class Employee {
private String eName;
private String gender;
private Department depart;
public void seteName(String eName) {
this.eName = eName;
}
public void setGender(String gender) {
this.gender = gender;
}
public Department getDepart() {
return depart;
}
public void setDepart(Department depart) {
this.depart = depart;
}
public void test(){
System.out.println(eName+" "+gender+" "+depart);
}
}
xml配置
外部bean注入方式：
<bean id="department" class="com.kk.bean.Department">
<property name="dname" value="finance"/>
</bean>
<bean id="employee" class="com.kk.bean.Employee">
<property name="eName" value="kk"/>
<property name="gender" value="male"/>
<property name="depart" ref="department"/>
</bean>
内部bean注入方式：
<bean id="employee" class="com.kk.bean.Employee">
<property name="eName" value="kk"/>
<property name="gender" value="male"/>
<property name="depart">
<bean id="department" class="com.kk.bean.Department">
<property name="dname" value="finance"/>
</bean>
</property>
</bean>
Test类
public class Test_ {
public static void main(String[] args) {
//1.加载spring配置文件
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//2.获取配置创建的对象
Employee employee = context.getBean("employee", Employee.class);
employee.test();
}
}
注入属性-级联赋值
级联赋值在使用上，是在一个bean对象中注入另一个bean对象（外部bean）的属性并对该属性进行赋值。上面代码的外部赋值就是一种级联赋值
外部bean注入方式：
<bean id="department" class="com.kk.bean.Department">
<property name="dname" value="finance"/>
</bean>
<bean id="employee" class="com.kk.bean.Employee">
<property name="eName" value="kk"/>
<property name="gender" value="male"/>
<property name="depart" ref="department"/>
</bean>
内部bean注入方式：
<bean id="employee" class="com.kk.bean.Employee">
<property name="eName" value="kk"/>
<property name="gender" value="male"/>
<property name="depart">
<bean id="department" class="com.kk.bean.Department">
<property name="dname" value="finance"/>
</bean>
</property>
</bean>
xml注入集合
常见集合：数组、Set、List、Map
创建bean类(Jihe)
public class Jihe {
private String[] idNum;
private List<String> name;
private Map<String,String> course;
private Set<String> grade;
//该类之前创建过
private List<Employee> employees;
public void setEmployees(List<Employee> employees) {
this.employees = employees;
}
public void setIdNum(String[] idNum) {
this.idNum = idNum;
}
public void setName(List<String> name) {
this.name = name;
}
public void setCourse(Map<String, String> course) {
this.course = course;
}
public void setGrade(Set<String> grade) {
this.grade = grade;
}
public void test(){
System.out.println(Arrays.toString(idNum));
System.out.println(name);
System.out.println(course);
System.out.println(grade);
for (Employee employee : employees) {
employee.test();
}
}
}
xml配置注入
<bean id="jihe" class="com.kk.bean.Jihe">
<property name="idNum">
<array>
<value>100321</value>
<value>103421</value>
<value>105421</value>
<value>105421</value>
</array>
</property>
<property name="name">
<list>
<value>name1</value>
<value>name2</value>
<value>name3</value>
</list>
</property>
<property name="course">
<map>
<entry key="9001" value="Java"></entry>
<entry key="9002" value="SQL"></entry>
<entry key="9003" value="web"></entry>
</map>
</property>
<property name="grade">
<set>
<value>99</value>
<value>299</value>
<value>919</value>
<value>499</value>
<value>499</value>
</set>
</property>
<!--当集合内需要创建对象时 在外部配置好属性-->
<property name="employees">
<list>
<ref bean="e1"></ref>
<ref bean="e2"></ref>
</list>
</property>
</bean>
<bean id="e1" class="com.kk.bean.Employee">
<property name="eName" value="k"></property>
</bean>
<bean id="e2" class="com.kk.bean.Employee">
<property name="eName" value="kk"></property>
</bean>
Test_测试
public class Test_ {
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
Jihe demo=context.getBean("jihe", Jihe.class);
demo.test();
}
}
IOC操作Bean管理（FactoryBean）
Spring有两种类型bean
一种是普通bean 一种是工厂bean(FactoryBean)
普通bean：定义的类型就是返回的类型
工厂bean：定义的类型可以与返回值类型不同
工厂bean的实现方式
创建一个类，让这个类作为工厂bean，实现接口FactoryBean
实现接口里的方法 在实现的方法中定义返回的bean类型
创建一个工厂bean（.java文件）此时设置传入类型为User类
public class MyBean implements FactoryBean<User> {
//返回实例
public User getObject() throws Exception {
Class<?> clazz = Class.forName("com.kk.User");
Constructor constructor = clazz.getConstructor();
User user = (User) constructor.newInstance();
user.setAge(11);
user.setName("kk");
return user;
}
//返回类型
public Class<?> getObjectType() {
return null;
}
//判断是否为单例
public boolean isSingleton() {
return false;
}
}
xml配置
<bean id="myBean" class="com.kk.factorybean.MyBean"></bean>
Test_测试
可以通过MyBean接收的不同类型设置不同的接收类型
public class Test_ {
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
// User myBean = context.getBean("myBean", User.class);
Object myBean = context.getBean("myBean", Object.class);
System.out.println(myBean.getClass());
System.out.println(myBean.toString());
}
}
Bean作用域
在Spring里面，默认情况下，bean是单实例对象
public class Test_ {
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
User u1 = context.getBean("myBean", User.class);
User u2 = context.getBean("myBean", User.class);
System.out.println(u1==u2);//true 说明每次创建都是同一个对象---单例
}
}
设置 单实例/多实例 对象
通过创建bean时设置 scope 属性 prototype(多)/singleton(单)
<bean id="myBean" class="com.kk.User" scope="prototype"></bean>
<bean id="myBean" class="com.kk.User" scope="singleton"></bean>
注意：
当默认或者设置为单实例对象时，在加载spring配置文件时就创建了单实例对象
当设置为多实例时，加载配置文件不会创建对象，而是在调用getBean方法时创建对象
Bean生命周期
- 通过构造器创建实例对象（无参构造）
- 为bean的属性设置值和对其他bean引用（调用set方法）
- 把bean实例传递bean后置处理的方法
- 调用bean的初始化方法（需进行配置初始化的方法）
- 把bean实例传递bean后置处理器的方法
- bean可以使用了（对象获取到了）
- 当容器关闭时，调用bean的销毁的方法（需进行配置销毁的方法）
实体类(Live)
public class Live {
private String name;
public Live() {
System.out.println("1 "+"无参构造");
}
public void setName(String name) {
this.name = name;
System.out.println("2 "+"设置参数");
}
public void Init_method(){
System.out.println("3 "+"初始化方法");
}
public void Destroy_method(){
System.out.println("5 "+"销毁");
}
}
xml配置文件
<bean id="Live" class="com.kk.bean.Live" init-method="Init_method" destroy-method="Destroy_method">
<property name="name" value="kk"/>
</bean>
<bean id="myBeanPost" class="com.kk.bean.MyBeanPost"></bean>
Test_测试类
public class Test_ {
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
Live demo1=context.getBean("Live",Live.class);
System.out.println("4 获取创建的bean对象");
((ClassPathXmlApplicationContext)context).close();
}
}
XML自动装配
在配置xml中bean的里面设置autowire
- 根据属性名称自动装配(byName)
- 更具属性值自动装配(byType)
byName
<!-- byName 注入值bean的id和类属性名一样-->
<bean id="employee" class="com.kk.bean.Employee" autowire="byName">
<!-- <property name="depart" ref="department"/> 该方法为手动注入-->
</bean>
<bean id="depart" class="com.kk.bean.Department"><property name="dname" value="1"/> </bean>
byType
<!-- byType 通过类型自动输入 缺点：当同时创建两个class相同的类就会报错-->
<bean id="employee" class="com.kk.bean.Employee" autowire="byType">
<!-- <property name="depart" ref="department"/> 该方法为手动注入-->
</bean>
<bean id="department" class="com.kk.bean.Department"><property name="dname" value="1"/> </bean>
引入外部的properties
前提：
xml头部配置加入：
xmlns:context=“http://www.springframework.org/schema/context”
创建properties文件 存放配置信息
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test
username=root
password=123456
把外部properties属性文件引入到spring配置文件中
引入contex名称空间
<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/util http://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
xml配置属性
//将properties文件引入到xml当中
<context:property-placeholder location="jdbc.properties"/>
//配置属性
<bean id="druid" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${driverClassName}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</bean>
Test_测试
public class Test_ {
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
Object object = context.getBean("druid",Object.class);
System.out.println(object);
}
}
基于注解方式实现
什么是注解：
注解是代码特殊标记，格式：＠注解名称（属性名称＝属性值，属 性名称＝属性值）
使用注解,注解作用在类上面,方法上面,属性上面
目的：简化xml配置
spring针对Bean管理中创建对象提供注解
功能都是一样的
- @Component --all
- @Service --service层
- @Controller --controller层
- @Repository --dao层
使用注解方式创建对象
- 引入依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.3.21</version>
</dependency>
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"
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">
- 开启组件扫描
在xml中引入组件扫描
<!--扫描多个包
1. 使用逗号隔开
2. 扫描包的上层目录-->
<context:component-scan base-package="com.kk.dao,com.kk.service"></context:component-scan>
- 创建类 在累的上面添加创建对象注解
//如果value不写，则默认值为该类首字母小写 UserService-->userService
@Component(value = "userService")//组件扫描配置（设置父包下哪些需要扫描
//示例1,需要扫描的内容
<context:component-scan base-package="com.kk.dao,com.kk.service" user-default-filter="false">
<context:include-filter type="annotion" expression="org.springframework.stereotype.Controller" />
</context:component-scan>
//示例2,不需要扫描的内容
<context:component-scan base-package="com.kk.dao,com.kk.service" user-default-filter="false">
<context:exclude-filter type="annotion" expression="org.springframework.stereotype.Controller" />
</context:component-scan>
注解实现属性注入
- @Autowired:根据属性类型进行自动装配
@Service(value = "userService")
public class UserService {
//不需要set方法 已经被封装了
//添加注入注解
@Autowired //类型注入(byType) 相当于创建了一个class=com.kk.dao.userDao的bean 然后注入到userService的bean的property当中(注入bean)
public UserDao userDao;
public void add(){
System.out.println("service add...");
}
}
@Repository
public class UserDaoImpl implements UserDao{
public void dao() {
System.out.println("dao dao...");
}
}
-
@Qualifler:根据属性名称进行注入,和Autowired一起使用
和byType一样如果使用@Autowired 当很多类实现Dao时该注解找不到 故要使用@Qualifler注解进行特指
@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao{
public void dao() {
System.out.println("dao dao...");
}
}
//当id被改变之后可以是用@Qualifier(..)特定指向name为(..)的值
@Service(value = "userService")
public class UserService {
//不需要set方法 已经被封装了
//添加注入注解
@Autowired
@Qualifier("userDaoImpl1")
public UserDao userDao;
public void add(){
System.out.println("service add...");
}
}
- @Resource:可以根据 类型注入,可以根据名称注入
使用@Resource(name=“…”)时按名称注入
使用@Resource时按类型注入
该注解是javax提供 import javax.annotation.Resource;
而上面两个注解
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
不建议使用@Resource - @Value:注入普通类型属性
相当于 配置bean时给里面property填上value值
@Service(value = "userService")
public class UserService {
@Value("kk")
private String name;
public void test(){
System.out.println("name:"+name);
}
}
public class Test_ {
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
UserService userService = context.getBean("userService", UserService.class);
userService.test();
}
}
完全注解开发
- 使用一个类去替代xml文件(此时xml当中就一个包扫描配置)
@Configuration//表明自己替代了xml配置文件
//包扫描
//@ComponentScan(basePackages = "com.kk")
@ComponentScans({@ComponentScan(basePackages = "com.kk.dao"),
@ComponentScan(basePackages = "com.kk.service")})
public class SpringConfig {
}
- 编写测试类 获取configuration返回的context
@Test
public void test2(){
AnnotationConfigApplicationContext context
= new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService", UserService.class);
userService.test();
}
Aop
AOP概念：
Aspect Oriented Programming：面向切面编程
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率
通俗描述：不通过修改源代码方式，在主干功能里面添加新功能
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x7eL9pk9-1665627438700)(AOP.png)]
AOP底层原理
AOP底层使用动态代理
- 有接口情况，使用JDK动态代理：创建接口实现类代理对象，增强类的方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GXNms5k2-1665627438702)(JDK动态代理.png)]
- 没有接口情况：使用CGLIB动态代理：创建子类的代理对象，增强类的方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lf2DeEwv-1665627438703)(CGLIB动态代理.png)]
JDK动态代理实现
调用newProxyInstance方法
start object newProxyInstance(Classloader loader,类[ ] interfaces,InvocationHandler h);
参数1：类加载器
参数2：增强方法所在的类，这个类实现的接口，支持多个接口
参数3：实现这个接口InvocationHandle，创建代理对象，写增强的部分
JDK代理步骤
-
创建接口，定义方法
-
创建实现类，实现方法（将方法功能增强）
-
使用Proxy创建接口代理对象
代码：
接口类
public interface UserDao {
public int sum(int a,int b);
public String update(String id);
}
实现类
public class UserDaoImpl implements UserDao{
public int sum(int a, int b) {
return a+b;
}
public String update(String id) {
return id;
}
}
代理类
public class JDKProxy {
public static void main(String[] args) {
Class[] interfaces = {UserDao.class};
//匿名内部类方式创建
// Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
// public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// return null;
// }
// });
//常规方式 创建一个类再导入对象
UserDao userDao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDapProxy(new UserDaoImpl()));
System.out.println(userDao.sum(1, 2));
System.out.println(userDao.update("3"));
}
}
class UserDapProxy implements InvocationHandler{
private Object object;
public UserDapProxy(Object object) {
this.object = object;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方法执行前
System.out.println("before "+method.getName()+ " 传递的参数： "+ Arrays.toString(args));
//增强方法执行
Object res = method.invoke(object, args);
//方法执行后
System.out.println("after "+object);
return res;
}
}
AOP常用术语
-
连接点：类里可被增强的方法称为连接点
-
切入点：实际真正被增强的方法称为切入点
-
通知（增强）：实际增强的逻辑部分称为通知增强
前置通知、后置通知、环绕通知、异常通知、最终通知 -
切面：是动作，把通知应用到切入点过程
使用前准备工作
-
Spring框架一般基于AspectJ实现AOP操作
AspectJ：面向切面的框架
AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。
Aspect不是Spring的组成部分，独立的AOP框架，一般Aspect和Spring框架一起使用进行AOP操作 -
基于AspectJ实现AOP操作
基于xml配置文件实现
基于注解方式实现（常用） -
在项目工程文件中引入AOP依赖包
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
- 切入点表达式
切入点表达式作用：知道哪个类里面的方法进行增强
语法结构：executio([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]))
例1：execution(* aop.bookdao.add(…))
例2：execution(* aop.bookdao.*(…))
AOP操作（Aspect注解）
- 创建类
@Component
public class User {
public void add(){
System.out.println("add...");
}
}
- 创建增强类，编写增强逻辑(UserProxy)
在增强类里面，创建方法，让不同方法代表不同通知类型
@Component
@Aspect //表明是代理对象 标记给配置文件看
public class UserProxy {
//该注解表示前置通知
@Before(value = "execution(* com.kk.User.add(..))")
public void before(){
System.out.println("before...");
}
}
-
进行类通知的配置
在Spring配置文件中，开启注解扫描
使用注解创建上述对象
在增强类上面添加注解@Aspect -
配置不同类型的通知
在增强类里面 在作为通知方法上面添加通知类型注解 使用切入点表达式配置
@Component
@Aspect //表明是代理对象 标记给配置文件看
public class UserProxy {
//该注解表示前置通知
@Before(value = "execution(* com.kk.User.add(..))")
public void before(){
System.out.println("before...");
}
@After(value = "execution(* src.aop.User.add(..))")
public void after(){
System.out.println("after...");
}
@AfterReturning(value = "execution(* src.aop.User.add(..))")
public void afterReturning(){
System.out.println("afterReturning...");
}
@AfterThrowing(value = "execution(* src.aop.User.add(..))")
public void afterThrowing(){
System.out.println("after throwing...");
}
@Around(value = "execution(* src.aop.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint)throws Throwable{
System.out.println("环绕前...");
proceedingJoinPoint.proceed();
System.out.println("环绕后...");
}
}
相同切入点的抽取
@Pointcut(value = "execution(* src.aop.User.add(..))")
public void pointdemo(){
}
@Before(value = "pointdemo()")
public void before(){
System.out.println("before...");
}
设置增强类优先级
有多个增强类对同一个方法进行增强，设置增强类优先级
在增强类上面添加注解@Order(数字类型值)，数值越小，优先级越大
@Component
@Aspect
@Order(1)
public class OtherProxy {
@After(value = "execution(* src.aop.User.add(..))")
public void after(){
System.out.println("OtherProxy...");
}
}
@Component
@Aspect//生成代理对象
@Order(3)
public class UserProxy {
@After(value = "execution(* src.aop.User.add(..))")
public void after(){
System.out.println("UserProxy...");
}
}
使用xml实现AOP
实体类
@Component
public class User {
public void add(){
System.out.println("add...");
}
}
代理类
@Component
public class UserProxy {
public void before(){
System.out.println("before...");
}
}
xml配置
<!--开启注解扫描-->
<context:component-scan base-package="com.kk"></context:component-scan>
<aop:config>
<!--配置切入点-->
<aop:pointcut id="p" expression="execution(* com.kk.User.add())"/>
<!--配置切面-->
<aop:aspect ref="userProxy">
<aop:before method="before" pointcut-ref="p" />
</aop:aspect>
</aop:config>
JdbcTemplate
什么是JdbcTemplate
Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作
使用jdbcTemplate实现增删改
jdbc.properties配置设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test?characterEncoding=utf-8
name=root
password=123456
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:aop="http://www.springframework.org/schema/aop"
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/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<context:component-scan base-package="com.kk.dao,com.kk.service">context:component-scan>
<context:property-placeholder location="jdbc.properties"/>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
<property name="driverClassName" value="${driverClassName}"/>
<property name="url" value="${url}"/>
<property name="username" value="${name}"/>
<property name="password" value="${password}"/>
bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource">property>
bean>
beans>
UserDao
public interface UserDao {
void addUser(User user);
}
UserDaoImple
@Repository
public class UserDaoImpl implements UserDao{
//注入JdbcTemplate对象 封装了jdbc直接可以是用
@Autowired
private JdbcTemplate jdbcTemplate;
//实现增加 （删除，修改类似）
public void addUser(User user) {
String sql = "insert into user values(?,?)";
int rows = jdbcTemplate.update(sql, user.getId(), user.getName());
System.out.println(rows>=1?"success":"fail");
}
}
UserService
@Service(value = "userService")
public class UserService {
//注入UserDao对象
@Autowired
private UserDao userDao;
public void addUser(User user){
userDao.addUser(user);
}
}
实现了增加的操作
test测试
@Test
public void test(){
ApplicationContext context
= new ClassPathXmlApplicationContext("bean1.xml");
UserService userService = context.getBean("userService", UserService.class);
userService.addUser(new User(1,"kkkkk"));
}
使用jdbcTemplate实现查找
dao和service和上面相似
daoImple
public List<User> selectAllUser() {
String sql = "select * from user";
//这里使用query方法
List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
return users;
}
SpringWebFlux
SpringWebflux介绍
-
spring5添加新的模块，用于web开发的功能和SpringMVC类似，Webflux使用当前一种比较流程响应式编程出现的框架
-
使用传统web框架，比如SpringMVC，这些基于Servlet容器，Webflux是一种异步非阻塞的框架，异步非阻塞的框架在Servlet3.1以后才支持，核心是基于Reactor的相关API实现的
-
什么是异步非阻塞？
异步和同步针对调用者：调用者发送请求（等待回应才去处理其他事情叫同步，不需要等待回应即可处理其他事情叫异步）
阻塞和非阻塞针对被调用者：处理完请求才给出反馈叫阻塞，不需要处理完请求就给出反馈叫非阻塞
- Webflux的特点
异步非阻塞：在有限资源下提高系统吞吐量和伸缩性，以Reactor为基础实现响应式编程
函数式编程：Webflux使用Java8函数式编程实现路由请求
- 比较SpringMVC
两个框架都可以使用注解方式，都运行在Tomcat容器中
SpringMVC采用命令式编程，Webflux采用异步非阻塞响应式编程
响应式编程
什么是响应式编程
响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播
Java8及其之前的版本
提供观察者模式两个类Observe和Observable
public class Test_ extends Observable{
@Test
public void test(){
Test_ observer = new Test_();
observer.addObserver((o,arg)->{
//添加观察者
System.out.println("发生了变化");
});
observer.addObserver((o,arg)->{
System.out.println("准备改变");
});
observer.setChanged();//监控数据是否发生变化
observer.notifyObservers();//通知
}
}
reactor实现响应式编程
导入pom
<dependency>
<groupId>io.projectreactorgroupId>
<artifactId>reactor-coreartifactId>
<version>3.1.5.RELEASEversion>
dependency>
<dependency>
<groupId>io.projectreactorgroupId>
<artifactId>reactor-testartifactId>
<version>3.2.3.RELEASEversion>
<scope>testscope>
dependency>
代码实现：
public static void main(String[] args) {
Flux.just(1,2,3,4);
Mono.just(1);
Integer[] arr = {1,2,3,4};
Flux.fromArray(arr);
List list = Arrays.asList(arr);
Flux.fromIterable(list);
Stream stream = list.stream();
Flux.fromStream(stream);
}
三种信号
错误信号和完成信号都是终止信号，但不能共存
如果没有发送任何元素值，而是直接发送错误或者完成信号，表示空数据流
如果没有错误信号，没有完成信号，则表示无限数据流
subscribe 订阅
调用just或者其它方法只是声明数据流，数据流并没有发出，只有进行订阅之后才会触发
public static void main(String[] args) {
Flux.just(1,2,3,4).subscribe(System.out::println);
Mono.just(99).subscribe(System.out::println);
}
操作符
对数据进行多道操作犹如工厂流水线
map：将元素映射为新元素
flatMap:元素映射为流