一.Spring 框架概述
1,Spring 是一个 开源的 轻量级的 JavaEE 框架。
轻量级:体积小,jar 独立应用不须要依赖其余 jar 包,
开源:收费,能够提供源代码
框架:解决开发的复杂性,简化企业开发。
2,spring 的两个外围局部:IOC,Aop
IOC:管制反转,把创建对象的过程交给 spring 进行治理。
Aop:面向切面,在不批改源代码的状况下,进行性能的增加或加强。
3,spring 框架的特点:
1),不便解耦,简化开发:对象与对象之间的关系依赖 spring。
2),Aop 编程反对:不扭转源代码,加强性能
3),不便测试;
4),不便集成各种优良框架。
5),不便进行食物治理,升高 API 的应用难度
6),java 源码经典学习范例。
4,入门案例:
1),下载 Spring5:
spring 网址 : spring.io
间接下载地址:https://repo.spring.io/artifa…
还要下载一个日志 jar 包,spring5 依赖于这个 jar 包 commons-login 这个 jar
下载链接:commons-logging-1.1.1.jar 下载及 Maven、Gradle 引入代码,pom 文件及包内 class - 时代 Java (nowjava.com)
我集体下载 5.2.6
2),下载实现当前,加入一个一般的 java 我的项目,将 jar 导入我的项目
3),应用 spring
(1),创立一般类,在类中创立一般办法
public class User {public void add(){System.out.println("add.......");
}
}
(2), 创立 spring 配置文件,在配置文件中配置文件配置创立的对象
a,Spring 配置文件应用 xml 文件配置
<?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">
<!-- 配置 User 对象创立 -->
<bean id = "user" class = "com.yuge.User"></bean>
</beans>
b,创立测试类 Test
public class Tset {
@Test
public void testAdd(){
//1. 读入上下文配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//2. 获取配置对象
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();}
}
c,测试后果,胜利创建对象,并调用办法
二,IOC 容器
1.IOC 底层原理
1),什么是 IOC:
管制反转,将对象的创立和对象之间的交互作用,都交给 spring 进行治理。
2),应用 IOC 的目标
为了升高耦合
3)IOC 入门案例
2,IOC 底层原理
1),xml 解析,工厂模式,反射
2)图解 IOC 底层原理
传统形式:
工厂模式:
IOC 模式:
3.IOC 接口(BeanFactory)
IOC 基于容器实现,IOC 容器的底层就是对象工厂
1),BeanFactory 接口:
IOC 容器的最根本实现,是 spring 外部的应用接口,不提倡给开发人员应用。
2),ApplicationContext 接口:
是 BeanFactory 的子接口,提供比 BeanFactory 更弱小的性能,个别为开发人员应用
3),两接口的区别
因为咱们在应用 Spring 框架时,个别都是配合网页应用,应用 BeanFactory 创建对象时,不会创建对象,而加载配置文件的时候,是在服务器启动的时候,应用 tomcat,都是将零碎加载文件等麻烦非空间的事放在 tomcat 启动时实现,以提供更好的用户体验,所以采纳 ApplicationContext 接口
4),applicationContext 的实现类
3.IOC 操作 Bean 治理(基于 xml)
1),什么是 bean 治理:
A,bean 治理包含两个步骤:Spring 创建对象和 Spring 属性注入
2),bean 治理的实现形式:
a,基于 xml 配置文件的实现形式
1. 基于 XML 形式创建对象
id 属性:给 class 类门路取个别名
class 属性:创建对象类的全门路
XML 形式创立默认对象默认应用空参结构器
2. 基于 XML 形式的属性注入
(1),DI:依赖注入,就是注入属性。
DI 与 IOC 的区别:DI 是 IOC 的一种实现。
形式一:应用 set 形式注入
(a),创立类的对象,创立 set 办法
(b),在配置文件中配置对象创立,配置属性注入
形式二:应用有参构造方法注入
形式三:p 名称空间注入:
第一步:
第二步:
3. 注入空值和特殊字符
一,注入空值
二,注入特殊符号
4,注入 bean
1),注入内部 bean
引入内部 bean,用 service 调用 Dao 层,就是引入内部 bean 的过程。
2)注入外部 bean 和 级联赋值
级联赋值形式 1:不须要 dept 的 get 办法。
级联赋值形式 2:第二种办法须要创立 dept 的 get 办法。
5. 注入汇合属性
0),创立 Stu 类,User 类
package com.yuge;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Stu {
// 数组类型
private String course[];
//List 类型
private List<String> name;
//Map 类型
private Map<String,String> map;
//Set 类型
private Set<String> set;
//List 类型中存入多个对象
private List<User> userList;
public void setUserList(List<User> userList) {this.userList = userList;}
public void setCourse(String[] course) {this.course = course;}
public void setName(List<String> name) {this.name = name;}
public void setMap(Map<String, String> map) {this.map = map;}
public void setSet(Set<String> set) {this.set = set;}
public void show(){System.out.println(Arrays.toString(course));
System.out.println(name);
System.out.println(map);
System.out.println(set);
System.out.println(userList);
}
}
package com.yuge;
public class User {
private String name;
public void setName(String name) {this.name = name;}
public void add(){System.out.println("add.......");
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
1).XML 注入数组类型属性
2),XML 注入 List 汇合属性
3),XML 注入 Map 汇合属性
4),XML 注入 Map 属性
5),在汇合中注入对象属性:
<?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:m="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 配置 Stu 对象创立 -->
<bean id="stu" class="com.yuge.Stu">
<!-- 注入数组属性 -->
<property name="course">
<array>
<value>javaSe</value>
<value>Mysql</value>
</array>
</property>
<!-- 注入 List 对象 -->
<property name="name">
<list>
<value> 武巴 </value>
<value> 巴巴 </value>
</list>
</property>
<!-- 注入 Map 对象 -->
<property name="map">
<map>
<entry key="JAVASE" value="javase"></entry>
<entry key="SPRING" value="Spring"></entry>
</map>
</property>
<!-- 注入 Set 对象 -->
<property name="set">
<set>
<value> 张三 </value>
<value> 小三 </value>
</set>
</property>
<!-- 在 list 中注入对象属性 -->
<property name="userList">
<list>
<ref bean="user1"></ref>
<bean id="user1=2" class="com.yuge.User">
<property name="name" value="李华"></property>
</bean>
</list>
</property>
</bean>
<bean id="user1" class="com.yuge.User">
<property name="name" value="李烨"></property>
</bean>
</beans>
6),创立测试类
package com.yuge.test;
import com.yuge.Stu;
import com.yuge.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.applet.AppletContext;
public class Tset {
@Test
public void testAdd(){
// 加载配置文件
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("bean2.xml");
// 创建对象
Stu stu = (Stu) applicationContext.getBean("stu");
stu.show();}
}
7),输入后果
8). 将汇合向上抽取为所有 bean 的公共汇合
第一步:引入新的名称空间:
第二步:应用 util 标签实现 list 汇合注入的向上抽取
创立新的 Book 类测试向上抽取注入 list
package com.yuge;
import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
import java.util.List;
public class Book {
private List<String> bookList;
public void setBookList(List<String> bookList) {this.bookList = bookList;}
public void test(){System.out.println(bookList);
}
}
配置 XML 文件抽取注入 list 的办法:
<?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:p="http://www.springframework.org/schema/p"
xmlns:util="http://www.springframework.org/schema/util"
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">
<util:list id="list">
<value>java 从入门到入土 </value>
<value>python 从入门到入狱 </value>
</util:list>
<bean id="book" class="com.yuge.Book">
<property name="bookList" ref="list"></property>
</bean>
</beans>
运行后果:抽取胜利
抽取之前的样子:
抽取之后的样子:
还能够抽取更多的对象。
6,Spring 中的两种 bean
1)一般 bean:XML 中定义什么类型就返回什么类型
2),工厂 bean:XML 中定义一个类型,能够返回其余类型
第一步:创立类作为工厂 bean,实现 FactoryBean 的接口
第二步:实现接口里的办法,在实现的办法中定义返回的 bean 类型
package com.yuge.factoryBean;
import com.yuge.Stu;
import org.springframework.beans.factory.FactoryBean;
public class Mybean implements FactoryBean<Stu> {
@Override
public Stu getObject() throws Exception {Stu stu = new Stu();
return stu;
}
@Override
public Class<?> getObjectType() {return null;}
@Override
public boolean isSingleton() {return false;}
}
第三步:配置 XML 文件
<bean id="myBean" class="com.yuge.factoryBean.Mybean">
</bean>
测试:@Test
public void testMyBean(){ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
Stu stu = context.getBean("myBean",Stu.class);
System.out.println(stu);
}
后果:
7,bean 的作用域:
在 XML 中配置 bean 时单实例还是多实例:
8,XML 的主动拆卸
主动拆卸:依据指定的拆卸规定,(属性名称或者属性类型),Spring 主动将匹配的属性值填入。
演示主动主动拆卸:
1,依据名称拆卸
2,依据属性类型拆卸
9,引入内部属性治理
4.IOC 操作 Bean(基于注解)
1,spring 针对创建对象提供的注解
第一步引入依赖:
第二步:开启组件扫描
第三步:创立类,在类上增加上注解。
1,@Component,都能够应用改注解创建对象
2,@Service,个别用于业务逻辑层,或者 service 层
3,@Controller,个别用于 Web 层
4,@Repository,个别用于 Dao 层
下面的资格注解,性能都一样,只是将每个注解用于不同层便于开发人员区别。
2,开启组件扫面配置的细节配置
3,应用注解出入属性
1),@Autowired:依据属性类型主动注入
第一步:应用注解在各个类中创建对象。
第二步:定义对象属性。在属性下面增加注解。不须要 set 办法。
2),@Qualifier:依据属性名注入
3),@Resource:能够依据属性名和属性类型注入
以上三种是注入对象,不是一般类型*
4),@Value:注入一般类型
4,齐全注解开发
1),创立配置类,代替 XML 配置文件
2),编写测试类
三,Aop
面向切面,不批改源码对性能进行增强。
1,什么是 AOP
对业务的各个逻辑进行隔离,从而使业务之间的逻辑耦合性升高,进步代码的可重用性,进步开发效率。
2,AOP 的底层原理
1,AOP 底层应用动静代理
1,有接口的动静代理,应用 JDK 的动静代理
创立接口的实现类的代理对象,加强类的办法
2,无接口的动静代理,应用 CGLIB 动静代理
创立子类的代理对象,加强类的办法
2,应用 JDK 的动静代理
应用 proxy 类实现动静代理
代码实现:
1,创立接口:
package com.JDK 动静代理;
public interface UserDao {public int add(int a,int b);
public String update(String id);
}
2,创立实现类
package com.JDK 动静代理;
public class UserDaoImpl implements UserDao{
@Override
public int add(int a, int b) {return a+b;}
@Override
public String update(String id) {return id;}
}
3,应用 proxy 类创立接口的动静代理对象
package com.JDK 动静代理;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.security.PublicKey;
import java.security.UnresolvedPermission;
import java.util.Arrays;
public class JDKProxy {public static void main(String[] args) {Class[] interfaces = {UserDao.class};
UserDao dao = (UserDao)Proxy.newProxyInstance(UserDaoProxy.class.getClassLoader(), interfaces, new UserDaoProxy(new UserDaoImpl()));
int res = dao.add(1, 2);
System.out.println(res);
}
}
class UserDaoProxy implements InvocationHandler{
// 须要将待加强性能的类的对象传递到代理类中,并通过构造方法,代理类的构造方法将其实例化
// 通过 UserDaoProxy 创立 UserDaoImpl 的代理对象
private Object obj;
public UserDaoProxy(Object obj){this.obj = obj;}
@Override
/**
* 减少逻辑写在这个办法内
* @ proxy: 代理对象
* @ method: 须要加强的办法
* @ args:要加强性能的办法须要的参数
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 办法之前
System.out.println("办法之前执行。。。"+method.getName()+"传递的参数:"+ Arrays.toString(args));
// 被加强办法执行
Object res = method.invoke(obj, args);
// 办法之后执行
System.out.println("办法之后执行。。。"+obj);
return res;
}
}
3,AOP 中的相干术语
1,连接点:那些办法能够被加强,那些办法就叫连接点。
2,切入点:世界真正被加强的办法就叫切入点。
3,告诉(加强):理论被加强的逻辑局部就叫告诉或者加强。
告诉有多种类型:
4,切面:把告诉利用到切入点的动作就叫做切面
## 4,AOP 的操作筹备
1,Spring 框架个别都是基于 AspectJ 实现 AOP 操作
AspectJ:不是 Spring 框架的一部分,独立于 AOP 的框架,个别将 Spring 和 AOP 框架一起应用进行 AOP 操作。
2,基于 AspectJ 实现 AOP 操作
(1),基于 XML 配置文件的 AOP 操作
(2),基于注解形式实现(应用)
3,在我的项目的过程中,引入 AOP 相干的依赖。
4, 切入点表达式
(1),切入点表达式作用:晓得对哪个类外面的那个办法进行加强。
(2),语法结构:
execution:([权限修饰符][返回类型][类全门路][办法名称](参数列表))
举例 1:execution(* (返回值能够省略)com.yuge.UserDaoImpl.add(..));
增强 com.yuge.UserDaoImpl 的 add()办法,传入的参数用.. 示意,权限修饰符用 *,返回值类型省略。
举例 2:execution( (返回值能够省略)com.yuge.UserDaoImpl.(..)); 对类中的所有办法增强。
举例 3:execution( (返回值能够省略)com.yuge..*(..)); 对包中所有类的所有办法增强
5,AOP 操作(AspectJ 注解)
1,创立一个类,在类中定义方法,应用注解在类中加强该办法。
package com.AOP 注解形式;
public class User {public void add(){System.out.println("add...................");
}
}
2,创立一个加强类,编写加强逻辑
package com.AOP 注解形式;
// 加强类
public class UserProxy {
// 前置告诉
public void before(){System.out.println("before.............");
}
}
3,进行告诉的配置
(0)、引入名称空间
(1),在 spring 的配置文件中,开启注解扫描
<!-- 开启注解扫描 -->
<context:component-scan base-package="com.AOP 注解形式"></context:component-scan>
(2),应用注解创立 User 对象和 UserProxy 对象。
(3),在加强类下面增加 @Aspect 注解
(4),在 spring 配置文件中开启生成代理对象。
<!– 开启 AspectJ 生成代理对象 –>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
(5),配置不同类型 的告诉
a,在加强类办法下面,增加告诉类型。应用切入点表达式配置
package com.AOP 注解形式;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
// 加强类
@Component
@Aspect // 生成代理对象
public class UserProxy {// 前置告诉, 增加了 Before 注解,则就会在 add()办法之前执行 before 办法。@Before("execution(* com.AOP 注解形式.User.add(..))")
public void before(){System.out.println("before.............");
}
// 在办法执行之后执行
@After("execution(* com.AOP 注解形式.User.add(..))")
public void after(){System.out.println("after.............");
}
// 在办法存在异样时执行
@AfterThrowing("execution(* com.AOP 注解形式.User.add(..))")
public void afterThrowing(){System.out.println("afterThrowing.............");
}
// 在办法返回之后执行
@AfterReturning("execution(* com.AOP 注解形式.User.add(..))")
public void afterReturning(){System.out.println("afterReturning.............");
}
// 增加盘绕办法,在办法执行前后都执行
@Around("execution(* com.AOP 注解形式.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {System.out.println("盘绕之前.............");
// 被加强的办法执行
proceedingJoinPoint.proceed();
System.out.println("盘绕之后..............");
}
}
package com.AOP 注解形式;
import org.springframework.stereotype.Component;
@Component
public class User {public void add(){System.out.println("add...................");
}
}
package com.AOP 注解形式;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
@org.junit.Test
public void testAdd(){
// 加载上下文配置,读取 xml 配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
// 获取对象
User user = (User)context.getBean("user");
user.add();}
}
<?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:p="http://www.springframework.org/schema/p"
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.AOP 注解形式"></context:component-scan>
<!-- 开启 AspectJ 生成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<bean id="user" class="com.AOP 注解形式.User"></bean>
</beans>
运行后果:
b,总结:
after 无论是否存在异样都会执行,afterReturning 存在异样时不会执行。
6,AOP 操作(AspextJ 注解)优化
1,提取雷同的切入点
// 抽取雷同的切入点
@Pointcut(value = "execution(* com.AOP 注解形式.User.add(..))")
public void pointCut(){}
// 前置告诉, 增加了 Before 注解,则就会在 add()办法之前执行 before 办法。@Before("pointCut()")
public void before(){System.out.println("before.............");
}
// 在办法执行之后执行
@After("execution(* com.AOP 注解形式.User.add(..))")
public void after(){System.out.println("after.............");
}
2,当有多个加强类对同一个办法进行加强时,设置加强类优先级
在多个加强类下面设置优先级应用 @Order(整型值)这个注解,整型值越小,优先级越高
// 加强类
@Component
@Aspect // 生成代理对象
@Order(3)
public class UserProxy {
// 抽取雷同的切入点
@Pointcut(value = "execution(* com.AOP 注解形式.User.add(..))")
public void pointCut(){}
@Component
@Aspect
@Order(0)
public class UserProxy2 {@Before("execution(* com.AOP 注解形式.User.add(..))")
public void before(){System.out.println("UserProxy2 加强类先执行。。。。。");
}
}
7,AOP 操作(XML 配置文件)
前提在 xml 中创立加强类和被加强类的对象
8,齐全注解开发
四,JdbcTemplate
1,JdbcTempalte 的概念
Spring 对 JDBC 进行封装,应用 JdbcTemplate 能够不便的对数据库的操作。
筹备工作:
引入依赖:
配置 XML 创立类注入属性
2,应用 JdbcTemplate 模板对数据库的增删改查
<context:component-scan base-package="com"/>
<bean id = "dataSource" class="com.druid.DruidDataSource" destroy-method="close">
<property name="url" value="jdbc:mysql://localhost:3306/jdbc_db"/>
<property name="username" value="root"/>
<property name="password" value="3.141592654"/>
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!-- 注入 dataSource 对象 -->
<property name="dataSource" ref="dataSource"></property>
</bean>
public interface BookDao {void add(Book book);
}
@Repository
public class BookDaoImpl implements BookDao {
// 注入 JdbcTemplate 对象
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public void add(Book book) {String sql = "insert into book values(?,?,?)";
int update = jdbcTemplate.update(sql, book.getId(), book.getName(), book.getPrice());
System.out.println(update);
}
}
@Service
public class BookService {
// 注入 BookDao 属性
@Autowired
private BookDao bookDao;
public void insert(Book book){bookDao.add(book);
}
}
package com.druid;
public class DruidDataSource {
String url;
String password;
String username;
String driverClassName;
public void setUrl(String url) {this.url = url;}
public void setPassword(String password) {this.password = password;}
public void setUsername(String username) {this.username = username;}
public void setDriverClassName(String driverClassName) {this.driverClassName = driverClassName;}
private void close() {}
}
package com.test;
import com.bean.Book;
import com.service.BookService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestJdbcTemplate {
@Test
public void test(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean4.xml");
BookService bookService = context.getBean("bookService", BookService.class);
Book book = new Book();
book.setId(1);
book.setName("一阳指");
book.setPrice(250);
bookService.insert(book);
}
}
查问返回某一个值
查问返回某一个对象
查问返回一个汇合
## 3,应用 JdbcTemplate 模板对数据库的批量操作
五,事务操作
1,事务的概念:
回顾:事务是指一组根本的数据操作单元,要么全副实现操作,要么全副都不实现操作。
典型事务场景:银行转账
事务的四大个性(ACID):原子性,一致性,隔离性,持久性
2,事务环境的搭建
3,spring 事务管理的介绍
1,事务增加到 JavaEE 的三层体系结构的 Service 层(业务逻辑层)
2,在 Spring 事务操作:
1),有两种形式:编程式(在办法中增加代码)和申明式(基于 XML 或者基于注解形式)
2),申明式事务管理:底层应用到 AOP
3),Spring 事务管理相干的 API
4,多事务之间事务的流传行为:
5,ioslation 对于事务的隔离级别:
事务的隔离性:多事务的操作之间不会相互影响
如果不思考隔离:会导致脏读,幻读,不可反复读的问题
解决隔离级别:
配置隔离级别:
6,对于事务的超时限度:
7,readOnly 是否只读:
8,rollbackFor:回滚
9,noRollbackFor:不回滚