Spring入门基础篇(一)
1. Spring地位
-
表述层
SpringMVC
-
业务逻辑层
Spring framework
-
数据持久层
Mybatis/Hibernate,Springdata
2. Spring的简介
2.1 什么是Spring
- Spring产生于2003年,是一个开放源码的设计层面框架,解决的是业务逻辑层和其他各层的松耦合问题。
- Spring是一个分层的JavaSE/EE full-stack(一站式)轻量级开源框架。
2.2 Spring产生背景
- 创始人:rod johnson rod johnson的百度百科
- Spring官网
- Spring优点
-
方便解耦合,简化开发。高内聚,低耦合。
Spring就是一个大工厂(容器),可以将所有对象创建和依赖关系维护,交给Spring管理
-
AOP编程的支持
Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能
-
声明式事务的支持
只需要通过配置就可以完成对事务的管理,而无需手动编程
-
方便程序的测试
Spring对Junit4支持,可以通过注解方便的测试Spring程序
-
方便集成各种优秀框架
Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:MyBatis、Quartz等)的直接支持
-
降低JavaEE API的使用难度
Spring 对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低
2.3 Spring的核心
- IOC 控制反转
- AOP 面向切面
2.4 Spring的体系结构
-
core container 核心容器
beans: 创建管理对象
core:核心
context:上下文,应用程序所处的环境(配置文件)
SpEL: spring的EL表达式
核心容器是创建项目必备的模块。 -
AOP:Spring的aop框架
-
aspects: aop框架
-
Data Access/Integration :对Dao层的整合
JDBC:整合jdbc,简化jdbc开发
ORM:整合orm框架
Transactions:事务的支持,TS是事务的关键字
注: Dao 是 data access object
-
Web
servlet:整合servlet
web:对web层的支持,整合SpringMVC
-
Test:整合junit
3. Spring的入门案例
3.1 IOC
控制反转。
将对象创建和管理的权限反转给Spring容器。对象创建调用权的转移。
3.2 DI
依赖注入。
在运行阶段动态地向依赖赋值的过程。
3.3 IOC入门案例
-
创建java项目,导入jar包
beans context core SpEL 必须的jar包 +comms-logging 日志管理
所以,要做一个spring项目,至少需要4+1个jar包
-
首先通过new方法,实现一个项目。
- pom.xml
<?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.test</groupId>
<artifactId>SpringDemo</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
</dependency>
</dependencies>
</project>
- UserDao.java 接口
package dao;
public interface UserDao {
void addUser();
void deleteUser();
}
- UserDaoIpml
package dao.impl;
import dao.UserDao;
public class UserDaoIpml implements UserDao {
public void addUser() {
System.out.println("添加用户");
}
public void deleteUser() {
System.out.println("删除用户");
}
}
- Test.java
package test;
import dao.UserDao;
import dao.impl.UserDaoIpml;
public class Test {
@org.junit.Test
public void test() {
UserDao userDao = new UserDaoIpml();
userDao.addUser();
userDao.deleteUser();
}
}
- 运行结果
现在通过new创建对象。接下来希望Spring帮我创建对象,并从Spring的容器中将对象拿出来。
-
编写配置文件,上下文。一般情况下,叫做ApplicationContext.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">
<!--bean:创建和管理一个对象
id:bean的唯一标识
class:类的全限定名称-->
<bean id="userdao" class="dao.impl.UserDaoIpml"></bean>
</beans>
实际上,一个bean对应一个对象的管理与创建。
- 改变Test代码
package test;
import dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
@org.junit.Test
public void test() {
/*
UserDao userDao = new UserDaoIpml();
userDao.addUser();
userDao.deleteUser();
*/
//加载配置文件,获取Spring容器
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
//从容器中获取对象,第一个参数是id,第二个是类
UserDao user=ac.getBean("userdao", UserDao.class);
user.addUser();
user.deleteUser();
}
}
3.4 DI入门案例
- 创建一个UserService接口类
package servie;
public interface UserService {
void addUser();
void deleteUser();
}
- 创建一个UserService的接口类UserServiceImpl.java
package servie.impl;
import dao.UserDao;
import dao.impl.UserDaoIpml;
import servie.UserService;
public class UserServiceImpl implements UserService {
//dao和service之间的耦合度比较高
UserDao dao=new UserDaoIpml();
public void addUser(){
dao.addUser();
}
public void deleteUser(){
dao.deleteUser();
}
}
3. 修改测试类和xml
4. bean的实例化
-
构造器创建
-
静态工厂
工厂就是创建对象的。里面所有的方法都是静态的。
-
实例工厂
里面的方法是非静态的。
先有工厂对象,再去调用方法。
5. bean的作用域
默认情况下,使用单例模式管理对象。
利用scope配置作用域。
- singleton:单例
- prototype:多例
- request:每次请求创建一个对象
- session:每个会话中创建一个对象
6. bean的生命周期
6.1 初始化方法
在获取对象之前初始化
6.2 销毁方法
在容器关闭以后销毁对象
7. 使用xml方式bean的装配
- 手工装配
- 设值注入:一个属性+set方法
- 构造注入:属性+有参构造 constructor-arg
- 自动装配
8. 使用注解方式bean的装配
- @component 默认id为类名,首字母小写
<bean class="">
- @component(“id”)
<bean id=" " class=" ">
- @controller:web层
- @service:service层
- @repository:dao层
不确定是哪一层,可以直接使用@component
- @Autowired :按照类型注入
- @Autowired +@Qualifier(" "):按照名称注入
- @Resource(name=" "):按照名称注入
9. 整合junit
10. 代理
10.1 什么是代理
代理在真正对象处理之前和之后实现数据的预处理、过滤等操作。
解决代码重复问题。
10.2 代理模式
-
静态代理
编译阶段,为目标类创建相应的代理类。
缺点:
需要为每个目标类创建一个代理类;
为每个代理类中的方法添加代理方法,代理方法过多时重复。
-
动态代理
运行阶段,动态为目标对象创建代理对象。
-
JDK动态代理
需要编写接口和实现类。
目前Java开发包中包含了对动态代理的支持,但是其实现只支持对接口的的实现。 其实现主要通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。
import dynamicdao.UserDao;
import dynamicdao.impl.UserDaoImpl;
import org.springframework.test.context.ContextConfiguration;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.InvocationHandler;
@ContextConfiguration(locations = "classpath:ApplicationContext.xml")
public class Test {
public static void main(String[] args) {
//目标对象
final UserDao dao = new UserDaoImpl();
//为目标对象创建对象
UserDao proxy = (UserDao) Proxy.newProxyInstance(dao.getClass().getClassLoader(), dao.getClass().getInterfaces(), new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开始");
Object obj = method.invoke(dao, args);
return obj;
}
}
);
proxy.addUser();
proxy.deleteUser();
}
}
-
cglib动态代理
只需要实现类。
创建目标对象的继承对象作为代理对象。
导入jar包: asm.jar cglib.jar
实际上,mybatis和spring.core中都有这两个jar包。
package cglibdao.Test;
import cglibdao.UserDaoImpl;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class Test {
public static void main(final String[] args) {
//目标对象
final UserDaoImpl dao=new UserDaoImpl();
//创建目标对象的继承对象作为代理对象
//1.enhancer
Enhancer enhancer=new Enhancer();
//2.设置父类
enhancer.setSuperclass(UserDaoImpl.class);
//3.处理方法,即代理方法
Callback callback=new MethodInterceptor() {
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("开始");
Object obj=method.invoke(dao);
System.out.println("结束");
return obj;
}
};
enhancer.setCallback(callback);
//4.创建代理对象
UserDaoImpl proxy=(UserDaoImpl) enhancer.create();
proxy.addUser();
proxy.deleteUser();
}
}
11. AOP
11.1 什么是AOP
面向切面编程,采用横向抽取的模式,在运行过程中,动态的向目标对象织入增强代码的思想。底层就采用动态代理。
11.2 AOP底层实现思想
jdk动态代理
cglib动态代理
有接口就调用jdk动态代理,无接口则用cglib动态代理。
11.3 应用场景
事务管理
性能测试
日志
11.4 AOP框架
spring aop
aspectj
jboss
11.5 专业术语介绍
target:目标对象,需要添加增强代码的类的对象
advice:通知,增强代码
jointpoint:连接点,可能增加增强代码的方法
pointcut:切入点,增加增强代码的方法
aspect:切面,切入点与增强代码之间形成的面。
weaving:织入,增强代码添加到切入点的过程。
11.6 AOP开发
- 编写接口和实现类
- 编写增强代码
- 织入
11.7 优秀博客
其他总结: