本学习笔记总结自【尚硅谷课程视频】
轻量级的开源的JavaEE框架。
为简化企业级应用开发而生,解决企业应用开发的复杂性。使用Spring可以使简单的JavaBean实现以前只有EJB才能实现的功能。
Spring有两个核心部分:IOC和AOP。
(1)IOC:控制反转,把创建对象过程交给Spring进行管理。
(2)AOP:面向切面,不修改源代码进行功能增强。
特点:
(2)下载地址
https://repo.spring.io/release/org/springframework/spring/
public class User {
public void add(){
System.out.println("add...");
}
}
(1)Spring配置文件使用xml格式。
<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="user" class="com.spring5.User">bean>
beans>
@Test
public void testAdd(){
//1.加载Spring配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
//2.获取配置创建的对象
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();
}
(1)控制反转,把对象创建和对象之间的调用过程,交给Spring进行管理。
(2)使用IOC目的:为了耦合度降低。
(3)做入门案例就是IOC实现。
xml解析、工厂模式、反射。
(1)BeanFactory
IOC容器基本实现,是Spring内部的使用接口,不提供开发人员进行使用。
加载配置文件时候不会创建对象,在获取对象(使用)才去创建对象。
(2)ApplicationContext
BeanFactory接口的子接口,提供更强大的功能,一般由开发人员进行使用。
加载配置文件时候就会把在配置文件对象进行创建。
(1)Bean管理指的是两个操作。
(2)Spring创建对象。
(3)Spring注入属性。
(1)基于XML配置文件方式实现。
(2)基于注解方式实现。
<bean id="user" class="com.spring5.User">bean>
(1)在spring配置文件中,使用bean标签,标签里面添加对应属性,就可以实现对象创建。
(2)在bean标签有很多属性,介绍常用的属性。
(3)创建对象时候,默认也是执行无参数构造方法完成对象创建。
(1)DI:依赖注入,就是注入属性。
(2)第一种注入方式:使用set方式进行注入。
**
* 演示使用set方法进行注入属性
*/
public class Book {
//创建属性
private String bname;
private String bauthor;
//创建属性对应的set方法
public void setBname(String bname) {
this.bname = bname;
}
public void setBauthor(String bauthor) {
this.bauthor = bauthor;
}
}
<bean id="book" class="com.spring5.Book">
<property name="bname" value="易筋经">property>
<property name="bauthor" value="达摩老祖">property>
bean>
(3)第二种注入方式:使用有参数构造进行注入。
/**
* 使用有参数构造注入
*/
public class Orders {
//属性
private String oname;
private String address;
//有参数构造
public Orders(String oname, String address) {
this.oname = oname;
this.address = address;
}
}
<bean id="orders" class="com.spring5.Orders">
<constructor-arg name="oname" value="电脑">constructor-arg>
<constructor-arg name="address" value="China">constructor-arg>
bean>
(4)p名称空间注入(了解)。
第一步 添加p名称空间在配置文件中。
<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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
第二步 进行属性注入,在bean标签里面进行操作
<bean id="book" class="com.spring5.Book" p:bname="九阳神功" p:bauthor="无名氏">
bean>
(1)字面量。
<property name="address">
<null/>
property>
<property name="address">
<value>
>]]>
value>
property>
(2)注入属性-外部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();
}
}
<bean id="userService" class="com.spring5.service.UserService">
<property name="userDao" ref="userDaoImpl">property>
bean>
<bean id="userDaoImpl" class="com.spring5.dao.UserDaoImpl">bean>
(3)注入属性-内部bean
一个部门有多个员工,一个员工属于一个部门。
部门是一,员工是多。
//部门类
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
}
//员工类
public class Emp {
private String ename;
private String gender;
//员工属于某一个部门,使用对象形式表示
private Dept dept;
public void setEname(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;
}
public void setDept(Dept dept) {
this.dept = dept;
}
}
<bean id="emp" class="com.spring5.bean.Emp">
<property name="ename" value="lucy">property>
<property name="gender" value="女">property>
<property name="dept">
<bean id="dept" class="com.spring5.bean.Dept">
<property name="dname" value="安保部">property>
bean>
property>
bean>
(4)注入属性-级联赋值
<bean id="emp" class="com.spring5.bean.Emp">
<property name="ename" value="lucy">property>
<property name="gender" value="女">property>
<property name="dept" ref="dept">property>
bean>
<bean id="dept" class="com.spring5.bean.Dept">
<property name="dname" value="财务部">property>
bean>
<bean id="emp" class="com.spring5.bean.Emp">
<property name="ename" value="lucy">property>
<property name="gender" value="女">property>
<property name="dept" ref="dept">property>
<property name="dept.dname" value="技术部">property>
bean>
<bean id="dept" class="com.spring5.bean.Dept">
<property name="dname" value="财务部">property>
bean>
(1)注入数组类型属性。
(2)注入List集合类型属性。
(3)注入Map集合类型属性。
public class Stu {
//1 数组类型属性
private String[] courses;
//2 list集合类型属性
private List<String> list;
//3 map集合类型属性
private Map<String,String> maps;
//4 set集合类型属性
private Set<String> sets;
public void setCourses(String[] courses) {
this.courses = courses;
}
public void setList(List<String> list) {
this.list = list;
}
public void setMaps(Map<String, String> maps) {
this.maps = maps;
}
public void setSets(Set<String> sets) {
this.sets = sets;
}
}
<bean id="stu" class="com.spring5.collectiontype.Stu">
<property name="courses">
<array>
<value>java课程value>
<value>数据库课程value>
array>
property>
<property name="list">
<list>
<value>张三value>
<value>小三value>
list>
property>
<property name="maps">
<map>
<entry key="JAVA" value="java">entry>
<entry key="PHP" value="php">entry>
map>
property>
<property name="sets">
<set>
<value>MySQLvalue>
<value>Redisvalue>
set>
property>
bean>
(4)在集合里面设置对象类型值
<bean id="course1" class="com.spring5.collectiontype.Course">
<property name="cname" value="Spring5框架">property>
bean>
<bean id="course2" class="com.spring5.collectiontype.Course">
<property name="cname" value="MyBatis框架">property>
bean>
<property name="courseList">
<list>
<ref bean="course1">ref>
<ref bean="course2">ref>
list>
property>
(5)把集合注入部分提取出来
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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/beans/spring-util.xsd">
beans>
<util:list id="bookList">
<value>易筋经value>
<value>九阴真经value>
<value>九阳神功value>
util:list>
<bean id="book" class="com.spring5.collectiontype.Book">
<property name="list" ref="bookList">property>
bean>
(1)Spring有两种类型bean,一种普通bean,另外一种工厂bean(FactoryBean)。
(2)普通bean:在配置文件中定义bean类型就是返回类型。
(3)工厂bean:在配置文件中定义bean类型可以和返回类型不一样。
public class MyBean implements FactoryBean<Course> {
//定义返回bean
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCname("abc");
return course;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return false;
}
}
//测试类
@Test
public void test3(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean3.xml");
Course course = context.getBean("myBean", Course.class);
System.out.println(course);
}
<bean id="myBean" class="com.spring5.factorybean.MyBean">
bean>
(1)在Spring里面,设置创建bean实例是单实例还是多实例。
(2)在Spring里面,默认情况下,bean是单实例对象。
(3)如何设置单实例还是多实例。
第一个值 默认值,singleton,表示是单实例对象。
第二个值 prototype,表示是多实例对象。
第一 singleton单实例,prototype多实例。
第二 设置scope值是singleton时候,加载spring配置文件时候就会创建单实例对象。设施scope值是prototype时候,不是在加载spring配置文件时候创建对象。在调用getBean方法时候创建多实例对象。
(1)生命周期:
(2)bean生命周期:
(3)演示bean生命周期:
public class Orders {
//无参数构造
public Orders(){
System.out.println("第一步 执行无参数构造创建bean实例");
}
private String oname;
public void setOname(String oname) {
this.oname = oname;
System.out.println("第二步 调用set方法设置属性值");
}
//创建执行的初始化的方法
public void initMethod(){
System.out.println("第三步 执行初始化的方法");
}
//创建执行的销毁的方法
public void destroyMethod(){
System.out.println("第五步 执行销毁的方法");
}
}
<bean id="orders" class="com.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
<property name="oname" value="手机">property>
bean>
//测试类
@Test
public void testBean3(){
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("bean4.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println("第四步 获取创建bean实例对象");
System.out.println(orders);
//手动让bean实例销毁
context.close();
}
(4)bean的后置处理器(加上后),bean生命周期有七步。
(5)演示添加后置处理器效果。
public class MyBeanPost implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("在初始化之前执行的方法");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("在初始化之后执行的方法");
return bean;
}
}
<bean id="myBeanPost" class="com.spring5.bean.MyBeanPost">bean>
(1)什么是自动装配?
(2)演示自动装配过程。
<bean id="emp" class="com.spring5.autowire.Emp" autowire="byName">
bean>
<bean id="dept" class="com.spring5.autowire.Dept">
<bean id="emp" class="com.spring5.autowire.Emp" autowire="byType">
bean>
<bean id="dept" class="com.spring5.autowire.Dept">
bean>
(1)直接配置数据库信息。
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver">property>
<property name="url" value="jdbc:mysql://localhost:3306/userDb">property>
<property name="username" value="root">property>
<property name="password" value="root">property>
bean>
(2)引入外部属性文件配置数据库连接池。
引入context名称空间
<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" 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">
在spring配置文件使用标签引入外部属性文件。
<context:property-placeholder location="classpath:jdbc.properties"/> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="${prop.driverClass}">property> <property name="url" value="${prop.url}">property> <property name="username" value="${prop.userName}">property> <property name="password" value="${prop.password}">property> bean>
(1)注解是代码特殊标记,格式:@注解名称(属性名称=属性值,属性名称=属性值…)。
(2)使用注解,注解作用在类上面,方法上面,属性上面。
(3)使用注解目的:简化xml配置。
(1)@Componet
(2)@Service
(3)@Controller
(4)@Repository
上面四个注解功能是一样的,都可以用来创建bean实例。
(1)第一步 引入依赖
(2)第二步 开启组件扫描
<context:component-scan base-package="com.spring5">context:component-scan>
(3)第三步 创建类,在类上面添加创建对象注解。
//在注解里面value属性值可以省略不写,
//默认值是类名称,首字母小写
//UserService == userService
@Component(value = "userService") // 等同
public class UserService {
public void add(){
System.out.println("service add...");
}
}
<context:component-scan base-package="com.spring5" use-default-filters="false">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
context:component-scan>
<context:component-scan base-package="com.spring5">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
context:component-scan>
(1)@Autoired:根据属性类型进行自动装配
@Service
public class UserService {
//定义dao类型属性
//不需要添加set方法
//添加注入属性注解
@Autowired
private UserDao userDao;
public void add(){
System.out.println("service add...");
userDao.add();
}
}
(2)@Qualifier:根据属性名称进行注入
//定义dao类型属性
//不需要添加set方法
//添加注入属性注解
@Autowired //根据类型注入
@Qualifier(value = "userDaoImpl1")//根据名称进行注入
private UserDao userDao;
(3)@Resource:可以根据类型注入,可以根据名称注入。
//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;
(4)@Value:注入普通类型属性。
@Value(value = "abc")
private String name;
(1)创建配置类,替代xml配置文件。
@Configuration //作为配置类,替代xml配置文件
@ComponentScan(basePackages = {
"com.spring5"})
public class SpringConfig {
}
(2)编写测试类。
@Test
public void testService2(){
//加载配置类
ApplicationContext context
= new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
(1)面向切面编程(面向方面编程),利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
(2)通俗描述:不通过修改源代码方式,在主干功能里面添加新功能。
(3)使用登录例子说明AOP。
(1)有两种情况动态代理。
创建接口实现类代理对象,增强类的方法。
创建子类的代理对象,增强类的方法。
(1)使用JDK动态代理,使用Proxy类里面的方法创建代理对象。
方法有三个参数:
第一个参数,类加载器。
第二个参数,增强方法所在的类,这个类实现的接口,支持多个接口。
第三个参数,实现这个接口InvocationHandler,创建代理对象,写增强的方法。
(2)编写JDK动态代理代码。
public interface UserDao {
public int add(int a,int b);
public String update(String id);
}
public class UserDaoImpl implements UserDao{
@Override
public int add(int a, int b) {
return a+b;
}
@Override
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() {
// @Override
// public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// return null;
// }
// });
UserDaoImpl userDao = new UserDaoImpl();
UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,new UserDaoProxy(userDao));
int result = dao.add(1, 2);
System.out.println("result:" + result);
}
}
//创建代理对象代码
class UserDaoProxy implements InvocationHandler{
//1 把创建的是谁的代理对象,把谁传递过来
//有参数构造传递
private Object obj;
public UserDaoProxy(Object obj){
this.obj = obj;
}
//增强的逻辑
@Override
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;
}
}
类里面哪些方法可以被增强,这些方法称为连接点。
实际被真正增强的方法,称为切入点。
(1)实际增强的逻辑部分称为通知(增强)。
(2)通知有多种类型。
是动作。把通知应用到切入点过程。
(1)什么是AspectJ?
(1)基于xml配置文件实现。
(2)基于注解方式实现(使用)。
(1)切入点表达式作用:知道对哪个类里面的哪个方法进行增强。
(2)语法结构:
execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表]))
举例1:对com.spring5.dao.BookDao类里面的add进行增强。
execution(* com.spring5.dao.BookDao.add(..))
举例2:对com.spring5.dao.BookDao类里面的所有的方法进行增强。
execution(* com.spring5.dao.BookDao.*(..))
举例3:对com.spring5.dao包里面所有类,类里面所有方法进行增强。
execution(* com.spring5.dao.*.*(..))
public class User {
public void add(){
System.out.println("add...");
}
}
(1)在增强类里面,创建方法,让不同方法代表不同通知类型。
//增强的类
public class UserProxy {
//前置通知
public void before(){
System.out.println("before...");
}
}
(1)在spring配置文件中,开启注解扫描。
<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.spring5.aopanno">context:component-scan>
beans>
(2)使用注解创建User和UserProxy对象。
(3)在增强类上面添加注解@Aspect。
(4)在spring配置文件中开启生成代理对象。
<aop:aspectj-autoproxy>aop:aspectj-autoproxy>
(1)在增强类的里面,在作为通知方法上面添加通知类型注解,使用切入点表达式配置。
//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
//前置通知
//Before注解表示作为前置通知
@Before(value = "execution(* com.spring5.aopanno.User.add(..))")
public void before(){
System.out.println("before...");
}
//最终通知
@After(value = "execution(* com.spring5.aopanno.User.add(..))")
public void after(){
System.out.println("after...");
}
//后置通知(返回通知)
@AfterReturning(value = "execution(* com.spring5.aopanno.User.add(..))")
public void afterReturning(){
System.out.println("afterReturning...");
}
//异常通知
@AfterThrowing(value = "execution(* com.spring5.aopanno.User.add(..))")
public void afterThrowing(){
System.out.println("afterThrowing...");
}
//环绕通知
@Around(value = "execution(* com.spring5.aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
System.out.println("环绕之前...");
//被增强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后...");
}
}
//相同切入点抽取
@Pointcut(value = "execution(* com.spring5.aopanno.User.add(..))")
public void pointdemo(){
}
//前置通知
//Before注解表示作为前置通知
@Before(value = "pointdemo()")
public void before(){
System.out.println("before...");
}
(1)在增强类上面添加注解@Order(数字类型值),数字类型值越小优先级越高。
@Component
@Aspect
@Order(1)
public class PersonProxy {
//前置通知
@Before(value = "execution(* com.spring5.aopanno.User.add(..))")
public void before(){
System.out.println("Person Before...");
}
}
(1)创建配置类,不需要创建xml配置文件。
@Configuration
//开启注解扫描
@ComponentScan(basePackages = {
"com.spring5"})
//开启AspectJ生成代理对象
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}
//增强类
public class BookProxy {
public void before(){
System.out.println("before...");
}
}
//被增强类
public class Book {
public void buy(){
System.out.println("buy...");
}
}
<bean id="book" class="com.spring5.aopxml.Book">bean>
<bean id="bookProxy" class="com.spring5.aopxml.BookProxy">bean>
<aop:config>
<aop:pointcut id="p" expression="execution(* com.spring5.aopxml.Book.buy(..))"/>
<aop:aspect ref="bookProxy">
<aop:before method="before" pointcut-ref="p"/>
aop:aspect>
aop:config>
(1)Spring框架对JDBC进行封装,使用JdbcTemplate方便实现对数据库操作。
(1)引入相关jar包。
(2)在spring配置文件配置数据库连接池。
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver">property>
<property name="url" value="jdbc:mysql://localhost:3306/user_db">property>
<property name="username" value="root">property>
<property name="password" value="admin">property>
bean>
(3)配置JdbcTemplate对象,注入DataSource。
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource">property>
bean>
(4)创建service类,创建dao类,在dao注入jdbcTemplate对象。
<context:component-scan base-package="com.spring5">context:component-scan>
@Service
public class BookService {
//注入dao
@Autowired
private BookDao bookDao;
}
@Repository
public class BookDaoImpl implements BookDao{
//注入JdbcTemplate
@Autowired
private JdbcTemplate jdbcTemplate;
}
public class User {
private String userId;
private String username;
private String ustatus;
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getUstatus() {
return ustatus;
}
public void setUstatus(String ustatus) {
this.ustatus = ustatus;
}
}
(1)在dao进行数据库添加操作。
(2)调用JdbcTemplate对象里面update方法实现添加操作。
有两个参数:
第一个参数:sql语句
第二个参数:可变参数,设置sql语句值。
//添加的方法
@Override
public void add(Book book) {
//1 创建sql语句
String sql = "insert into t_book value(?,?,?)";
//2 调用方法实现
Object[] args = {
book.getUserId(),book.getUsername(),book.getUstatus()};
int update = jdbcTemplate.update(sql,args);
System.out.println(update);
}
@Test
public void testJdbcTemplate(){
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
BookService bookService = context.getBean("bookService", BookService.class);
Book book = new Book();
book.setUserId("1");
book.setUsername("java");
book.setUstatus("a");
bookService.addBook(book);
}
//1、修改
@Override
public void updateBook(Book book) {
String sql = "update t_book set username=?,ustatus=? where user_id=?";
Object[] args = {
book.getUsername(),book.getUstatus(),book.getUserId()};
int update = jdbcTemplate.update(sql, args);
System.out.println(update);
}
//2、删除
@Override
public void delete(String id) {
String sql = "delete from t_book where user_id=?";
int update = jdbcTemplate.update(sql, id);
System.out.println(update);
}
有两个参数
第一个参数:sql语句。
第二个参数:返回类型Class。
//查询表记录数
@Override
public int selectCount() {
String sql = "select count(*) from t_book";
Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
return count;
}
(1)有三个参数:
//查询返回对象
@Override
public Book findBookInfo(String id) {
String sql = "select * from t_book where user_id=?";
Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
return book;
}
(1)有三个参数:
//查询返回集合
@Override
public List<Book> findAllBook() {
String sql = "select * from t_book";
List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
return bookList;
}
操作表里面多条纪录。
(1)有两个参数:
//批量添加
@Override
public void batchAddBook(List<Object[]> batchArgs) {
String sql = "insert into t_book values(?,?,?)";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}
//测试
//批量添加
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {
"3","java","a"};
Object[] o2 = {
"4","c++","b"};
Object[] o3 = {
"5","MySQL","c"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量添加
bookService.batchAdd(batchArgs);
//批量修改
@Override
public void batchUpdateBook(List<Object[]> batchArgs) {
String sql = "update t_book set username=?,ustatus=? where user_id=?";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}
//测试
//批量修改
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {
"java0909","a3","3"};
Object[] o2 = {
"c++1010","b4","4"};
Object[] o3 = {
"MySQL1111","c5","5"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用方法实现批量修改
bookService.batchUpdate(batchArgs);
//批量删除
@Override
public void batchDeleteBook(List<Object[]> batchArgs) {
String sql = "delete from t_book where user_id=?";
int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
System.out.println(Arrays.toString(ints));
}
//测试
//批量删除
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {
"3"};
Object[] o2 = {
"4"};
batchArgs.add(o1);
batchArgs.add(o2);
//调用方法实现批量删除
bookService.batchDelete(batchArgs);
(1)事务是数据库操作最基本单元,逻辑上一组操作,要么都成功,如果有一个失败所有操作都失败。
(2)典型场景:银行转账。
lucy转账100元给mary
lucy少100,mary多100
(1)原子性:
(2)一致性:
(3)隔离性:
(4)持久性:
(1)service注入dao,在dao注入JdbcTemplate,在JdbcTemplate注入DataSource。
@Service
public class UserService {
//注入dao
@Autowired
private UserDao userDao;
}
@Repository
public class UserDaoImpl implements UserDao {
//注入JdbcTemplate模板对象
@Autowired
private JdbcTemplate jdbcTemplate;
}
<context:component-scan base-package="com.spring5">context:component-scan>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql:///user_db?characterEncoding=utf8" />
<property name="username" value="root" />
<property name="password" value="admin" />
bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource">property>
bean>
//lucy转账100给mary
//少钱
@Override
public void reduceMoney() {
String sql = "update t_account set money=money-? where username=?";
jdbcTemplate.update(sql,100, "lucy");
}
//多钱
@Override
public void addMoney() {
String sql = "update t_account set money=money+? where username=?";
jdbcTemplate.update(sql,100, "mary");
}
//转账的方法
public void accountMoney(){
//lucy少100
userDao.reduceMoney();
//mary多100
userDao.addMoney();
}
(1)上面问题如何解决呢?
(2)事务操作过程。
(1)有两种方式:编程式事务管理和声明式事务管理(使用)
(1)基于注解方式
(2)基于xml配置文件方式
(1)提供一个接口,代表事务管理器,这个借口针对不同的框架提供不同的实现类。
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource">property>
bean>
(1)在spring配置文件引入名称空间tx。
<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"
xmlns:tx="http://www.springframework.org/schema/tx"
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
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
(2)开启事务注解。
<tx:annotation-driven transaction-manager="transactionManager">tx:annotation-driven>
(1)@Transactional,这个注解添加到类上面,也可以添加到方法上面。
(2)如果把这个注解添加到类上面,这个类里面所有的方法都添加事务。
(3)如果把这个注解添加方法上面,为这个方法添加事务。
@Service
@Transactional
public class UserService {
}
(1)多事务方法之间进行调用,这个过程中事务是如何进行管理的。
(1)事务有特性称为隔离性,多事务操作之间不会产生影响。不考虑隔离性会产生很多问题。
(2)有三个读问题:脏读、不可重复读、虚(幻)读。
(3)脏读:一个未提交事务读取到另一个未提交事务的数据。
(4)不可重复读:一个未提交事务读取到另一提交事务修改数据。
(5)虚读:一个未提交事务读取到另一提交事务添加数据。
(6)解决:通过设置事务隔离级别,解决读问题。
mysql默认使用REPEATABLE READ。
(1)事务需要在一定时间内进行提交,如果不提交进行回滚。
(2)默认值是-1(不超时),设置时间以秒单位进行计算。
(1)读:查询操作,写:添加修改删除操作。
(2)readOnly默认值false,表示可以查询,可以添加修改删除操作。
(3)设置readOnly值是true,设置成true之后,只能查询。
(1)设置出现哪些异常进行事务回滚。
(1)设置出现哪些异常不进行事务回滚。
(1)第一步 配置事务管理器。
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource">property>
bean>
(2)第二步 配置通知。
<tx:advice id="txadvice">
<tx:attributes>
<tx:method name="accountMoney" propagation="REQUIRED"/>
tx:attributes>
tx:advice>
(3)第三步 配置切入点和切面。
<aop:config>
<aop:pointcut id="pt" expression="execution(* com.spring5.service.UserService.*(..))"/>
<aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
aop:config>
@Configuration //配置类
@ComponentScan(basePackages = "com.spring5") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {
//创建数据库连接池
@Bean
public DruidDataSource getDruidDataSource(){
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///user_db?characterEncoding=utf8");
dataSource.setUsername("root");
dataSource.setPassword("admin");
return dataSource;
}
//创建JdbcTemplate对象
@Bean
public JdbcTemplate getJdbcTemplate(DataSource dataSource){
//到ioc容器中根据类型找到dataSource
JdbcTemplate jdbcTemplate = new JdbcTemplate();
//注入dataSource
jdbcTemplate.setDataSource(dataSource);
return jdbcTemplate;
}
//创建事务管理器
@Bean
public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
return transactionManager;
}
}
(1)Spring5已经移除Log4jConfigListener,官方建议使用Log4j2。
(2)Spring5框架整合Log4j2。
<configuration status="INFO">
<appenders>
<console name="Console" target="SYSTEM_OUT">
<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
console>
appenders>
<loggers>
<root level="info">
<appender-ref ref="Console"/>
root>
loggers>
configuration>
(1)@Nullable注解可以使用在方法上面,属性上面,参数上面,表示方法返回可以为空,属性值可以为空参数值可以为空。
(2)注解用在方法上面,方法返回值可以为空。
(3)注解使用在方法参数里面,方法返回值可以为空。
(4)注解使用在属性上。
//函数式风格创建对象,交给spring进行管理
@Test
public void testGenericApplicationContext(){
//1 创建GeneriaApplicationContext对象
GenericApplicationContext context = new GenericApplicationContext();
//2 调用context的方法对象注册
context.refresh();
context.registerBean("user1",User.class,()->new User());
//3 获取在spring注册的对象
//User user = (User)context.getBean("com.spring5.test.User");
User user = (User)context.getBean("user1");
System.out.println(user);
}
(1)第一步 引入Spring相关针对测试依赖。
(2)第二步 创建测试类,使用注解方法完成。
@RunWith(SpringJUnit4ClassRunner.class) //单元测试框架
@ContextConfiguration("classpath:bean1.xml") //加载配置文件
public class JTest4 {
@Autowired
private UserService userService;
@Test
public void test1(){
userService.accountMoney();
}
}
(1)第一步 引入JUnit5的jar包。
(2)第二步 创建测试类,使用注解完成。
@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:bean1.xml")
public class JTest5 {
@Autowired
private UserService userService;
@Test
public void test1(){
userService.accountMoney();
}
}
(3)使用一个复合注解替代上面两个注解完成整合
@SpringJUnitConfig(locations = "classpath:bean1.xml")
public class JTest5 {
@Autowired
private UserService userService;
@Test
public void test1(){
userService.accountMoney();
}
}
(1)是Spring5添加新的模块,用于web开发的,功能与SpringMVC类似的,Webflux使用当前一种比较流行的响应式框架出现的框架。
(2)使用传统web框架,比如SpringMVC,这些基于Servlet容器,Webflux是一种异步非阻塞的框架,异步非阻塞的框架在Servlet3.1以后才支持,核心是基于Reactor(响应式编程)的相关API实现的。
(3)解释什么是异步非阻塞。
异步同步
非阻塞和阻塞
**上面都是针对对象不一样
(4)Webflux特点:
(5)比较SpringMVC。
(1)什么是响应式编程?
响应式编程是一种面向数据流和变化传播的编程范式,这意味着可以在编程语言中很方便地表达静态或动态的数据流,而相关的计算模型会自动将变化的值通过数据流进行传播。
电子表格程序就是响应式编程的一个例子,单元格可以包含字面值或类似“=B1+C1”的公式,而包含公式的单元格的值会依据其他单元格的值的变化而变化。
(2)Java8及其之前版本。
public class ObserverDemo extends Observable {
public static void main(String[] args) {
ObserverDemo observer = new ObserverDemo();
//添加观察者
observer.addObserver((o,arg)->{
System.out.println("发生变化");
});
observer.addObserver((o,arg)->{
System.out.println("手动被观察者通知,准备改变");
});
observer.setChanged(); //数据变化
observer.notifyObservers(); //通知
}
}
(3)Reactor实现。
第一步 引入依赖
<dependency> <groupId>io.projectreactorgroupId> <artifactId>reactor-coreartifactId> <version>3.1.5.RELEASEversion> dependency>
第二步 编写代码
public static void main(String[] args) { //just方法直接声明 Flux.just(1,2,3,4); Mono.just(1); //其他的方法 Integer[] array = { 1,2,3,4}; Flux.fromArray(array); List<Integer> list = Arrays.asList(array); Flux.fromIterable(list); Stream<Integer> stream = list.stream(); Flux.fromStream(stream); }
错误信号和完成信号都是终止信号,不能共存的。
如果没有发送任何元素值,而是直接发送错误或者完成信号,表示是空数据流。
如果没有错误信号,没有完成信号,表示是无限数据流。
//just方法直接声明
Flux.just(1,2,3,4).subscribe(System.out::print);
Mono.just(1).subscribe(System.out::print);
对数据流进行一道道操作,称为操作符,比如工厂流水线。
第一 map 元素映射为新元素
第二 flatmap 元素映射为流
把每个元素转换流,把转换之后多个流合并成大的流。
SpringWebflux基于Reactor,默认容器是Netty,Netty是高性能,NIO框架,异步非阻塞的框架。
(1)Netty。
(2)SpringWebflux执行过程和SpringMVC相似。
HandlerMapping:请求查询到处理的方法。
HandlerAdapter:真正负责请求处理。
HandlerResultHandler:响应结果处理。
SpringWebflux实现方式有两种:注解编程模型和函数式编程模型。
使用注解编程模型方式,和之前SpringMVC使用相似,只需要把相关依赖配置到项目中,SpringBoot自动配置相关运行容器,默认情况下使用Netty服务器。
第一步 创建SpringBoot工程,引入WebFlux依赖。
第二步 配置启动端口号。
第三步 创建包和相关类。
实体类:
创建接口定义操作方法:
接口实现类:
创建Controller:
说明:
SpringMVC方式实现,同步阻塞的方式,基于SpringMVC+Servlet+Tomcat。
SpringWebflux方式实现,异步非阻塞方式,基于SpringWebflux+Reactor+Netty。
(1)在使用函数式编程模型操作时候,需要自己初始化服务器。
(2)基于函数式编程模型时候,有两个核心接口:RouterFunction(实现路由功能,请求转发给对应的handler)和HandlerFunction(处理请求生成响应的函数)。核心任务定义两个函数式接口的实现并且启动需要的服务器。
(3)SpringWebflux请求和响应不再是ServletRequest和ServletResponse,而是ServerRequest和ServerResponse。
(4)编程实现。
public class UserHandler{
private final UserService userService;
public UserHandler(UserService userService){
this.userService = userService;
}
//根据id查询
public Mono<ServerResponse> getUserById(ServerRequest request){
//获取id值
int userId = Integer.valueOf(request.pathVariable("id"));
//空值处理
Mono<ServerResponse> notFound = ServerResponse.notFound().build();
//调用service方法得到数据
Mono<User> userMono = this.userService.getUserById(userId);
//把userMono进行转换返回
//使用Reactor操作符flatMap
return
userMono
.flatMap(person->ServerResponse.ok().contentType(MediaType.APPLICATION_JSON
.body(fromObject(person))))
.switchIfEmpty(notFound);
}
//查询所有
public Mono<ServerResponse> getAllUsers(){
//调用service得到结果
Flux<User> users = this.userService.getAllUser();
return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users,User.class);
}
//添加
public Mono<ServerResponse> saveUser(ServerRequest request){
//得到user对象
Mono<User> userMono = request.bodyToMono(User.class);
return ServerResponse.ok().build(this.userService.saveUserInfo(userMono));
}
}
创建路由的方法。
public class Server{ //1 创建router路由 public RouterFunction<ServerResponse> routingFunction(){ //创建handler对象 UserService userServie = new UserServiceImpl(); UserHandler handler = new UserHandler(userServie); //设置路由 RouterFunction.route( GET("/users/{id}").and(accept(APPLICAION_JSON),handler::getUserById).andRoute(GET("/users").and(accept(APPLICAION_JSON)),handler::getAllUsers); ); } }
创建服务器,完成适配。
//2 创建服务器完成适配 public void createReactorServer(){ //路由和handler适配 RouterFunction<ServerResponse> route = routingFunction(); HttpHandler httpHandler = toHttpHandler(route); ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler); //创建服务器 HttpServer httpServer = HttpServer.create(); httpServer.handle(adapter).bindNow(); }
最终调用
public static void main(String[] args) throws Exception{ Server server = new Server(); server.createReactorServer(); System.out.println("enter to exit"); System.in.read(); }
public class Client{
public static void main(String[] args){
//调用服务器地址
WebClient webClient = WebClient.create("http://127.0.0.1:5794");
//根据id查询
String id = "1";
User userresult = webClient.get().uri("/users/{id}",id)
.accept(MediaType.APPLICATION_JSON).retrieve().bodyToMono(User.class)
.block();
System.out.println(userresult.getName());
//查询所有
Flux<User> results = webClient.get().uri("/users")
..accept(MediaType.APPLICATION_JSON).retrieve().bodyToFlux(User.class);
results.map(stu -> stu.getName())
.buffer().doOnNext(System.out::println).blockFirst();
}
1、Spring框架概述
(1)轻量级开源JavaEE框架,为了解决企业复杂性,两个核心组成:IOC和AOP。
(2)Spring5版本。
2、IOC容器
(1)IOC底层原理(工厂、反射等)。
(2)IOC接口(BeanFactory)。
(3)IOC操作Bean管理(基于xml)。
(4)IOC操作Bean管理(基于注解)。
3、AOP
(1)AOP底层原理:动态代理,有接口(JDK动态代理),没有接口(CGLIB动态代理)。
(2)术语:切入点、增强(通知)、切面。
(3)基于AspectJ实现AOP操作。
4、JdbcTemplate
(1)使用JdbcTemplate实现数据库curd操作。
(2)使用JdbcTemplate实现数据库批量操作。
5、事务管理
(1)事务概念。
(2)重要概念(传播行为和隔离级别)。
(3)基于注解实现声明式事务管理。
(4)完全注解方式实现声明式事务管理。
6、Spring5新功能
(1)整合日志框架。
(2)@Nullable注释。
(3)函数式注册对象。
(4)整合JUnit5单元测试框架。
(5)SpringWebflux使用。