spring全家桶：spring ， springmvc ，spring boot , spring cloud
- 依赖
class a中使用class b的属性或者方法， 叫做classa依赖classb
Spring
1. IOC(控制反转)
IoC (Inversion of Control) : 控制反转， 是一个理论，概念，思想。
描述的：把对象的创建，赋值，管理工作都交给代码之外的容器实现。
控制： 创建对象，对象的属性赋值，对象之间的关系管理。
反转： 把容器代替开发人员管理对象。创建对象，给属性赋值。
正转：由开发人员在代码中，使用new 构造方法创建对象， 开发人员主动管理对象。
public static void main(String args[]){
Student student = new Student(); // 在代码中， 创建对象。--正转。
}
容器：是一个服务器软件， 一个框架（spring）
为什么要使用 ioc ：
目的就是减少对代码的改动， 也能实现不同的功能。 实现解耦合
java中创建对象有哪些方式：
1. 构造方法 ， new Student（）
2. 反射
3. 序列化
4. 克隆
5. ioc ：容器创建对象
6. 动态代理
ioc的体现：
servlet 1： 创建类继承HttpServelt
2: 在web.xml 注册servlet ， 使用
<servlet-name> myservlet </servlet-name>
<servelt-class>com.bjpwernode.controller.MyServlet1</servlet-class>
3. 没有创建 Servlet对象， 没有 MyServlet myservlet = new MyServlet()
4. Servlet 是Tomcat服务器它能你创建的。 Tomcat也称为容器
Tomcat作为容器：里面存放的有Servlet对象， Listener ， Filter对象
junit : 单元测试， 一个工具类库，做测试方法使用的。
使用单元测试
1.需要加入junit依赖。
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
2.创建测试作用的类：叫做测试类
src/test/java目录中创建类
3.创建测试方法
1）public 方法
2）没有返回值 void
3）方法名称自定义，建议名称是test + 你要测试方法名称
4）方法没有参数
5）方法的上面加入 @Test ,这样的方法是可以单独执行的。 不用使用main方法
IOC如何创建对象
1、声明一个bean,就是告诉spring要创建某个类的对象
id：对象的自定义名称，spring就是通过这个ID找到对象
class：类的全路径名称
Spring b把创建的对象放在map集合，
SpringMap.put(id , 对象)
xml文件 这就创建对象了
<bean id = "要创建对象的类名 别名 也可以是一样的 如：SomeServiceImpl的别名someService" class = "SomeServiceImpl的全路径名称" />
一个测试类
@Test
public voidtest（）{
// 使用spring容器创建对象
1、指定spring配置文件的名称
String config = "bean.xml";
2、创建spring容器对象 ApplicationContext
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
3、从容器中取对象 getbean(配置文件中bean的id)
SomeService s = (SomeService)ac.getbean("someService");
4、使用spring创建对象
s.dosome(); // dosome 是SomeService类中的方法
}
如同 SomeServiceImpl s = new SomeServiceImpl();
s.dosome();
IoC的技术实现
DI 是ioc的技术实现，
DI（Dependency Injection） :依赖注入， 只需要在程序中提供要使用的对象名称就可以， 至于对象如何在容器中创建，
赋值，查找都由容器内部实现。
spring是使用的di实现了ioc的功能， spring底层创建对象，使用的是反射机制。
spring是一个容器，管理对象，给属性赋值， 底层是反射创建对象。
set方法注入
类：
public class Student(){
private String name;
private int age;
private School school； //引用数据类型
无参构造函数
有参的构造函数
private void setName(String name){
this.name = name;
}
private void setAge(int age){
this.age= age;
}
private void setschool(School school){
this.school= school;
}
}
public class School (){
private String name;
无参构造函数
有参的构造函数
private void setName(String name){
this.name = name;
}
}
Spring 调用类中的set方法，给参数注入值
语法：
简单类型的set注入
> 1、语法
> > <bean id = "要创建对象的类名 如：someService" class = "SomeService的全路径名称" >
<property name = "参数名" value="值"/>
</bean>
xml文件
<bean id = "student" class = "Student的全路径名称" >
<property name = "name" value="老师"/>
<property name = "age" value="20"/>
</bean>
引用数据类型的set注入
2、语法
<bean id = "要创建对象的类名 如：someService" class = "SomeService的全路径名称" >
<property name = "参数名" ref=" 要引用的对象的bean的id"/>
</bean>
<bean id = "student" class = "Student的全路径名称" >
<property name = "name" value="老师"/>
<property name = "age" value="20"/>
<property name = "school" ref="school"/>
</bean>
<bean id = "school" class = "School的全路径名称" >
<property name = "name" value="清华"/>
</bean>
构造方法的注入
spring调用有参构造方法。在创建对象的时候注入值
语法
<bean id = "要创建对象的类名 如：someService" class = "SomeService的全路径名称" >
<donstructor-arg name = "参数名" value = "值"/> name :构造方法的形参名
或者
<donstructor-arg index= "0" value = "值"/> index 构造方法的形参名的位置 0 1 2
或者
value 构造方法的形参是简单类型的
ref：构造方法形参是引用类型
</bean>
<bean id = "student" class = "Student的全路径名称" >
<donstructor-arg name = "name" value = "张三"/>
<donstructor-arg name = "age" value = "20"/> name :构造方法的形参名
或者
<donstructor-arg index= "0" value = "张三"/> index 构造方法的形参名的位置 0 1 2
<donstructor-arg index= "1" value = "20"/>
<donstructor-arg index= "3" ref= "school"/>
ref：构造方法形参是引用类型s
</bean>
<bean id = "school" class = "School的全路径名称" >
<property name = "name" value="清华"/>
</bean>
引用数据类型的自动注入
byName
1、byName(按名称注入)：Java类中引用数据类型的属性名和spring容器中（配置文件）引用类性的bean id 名一样
<bean id = "myStudent" class = "Student的全路径名称" autowire = "byName">
基本数据类型的赋值
</bean>
<bean id = "myStudent" class = "Student的全路径名称" autowire = "byName">
<donstructor-arg name = "name" value = "张三"/>
<donstructor-arg name = "age" value = "20"/> name :构造方法的形参名
// <donstructor-arg index= "3" ref= "school"/>
ref：构造方法形参是引用类型
</bean>
<bean id = "school" class = "School的全路径名称" >
<property name = "name" value="清华"/>
</bean>
byType
byType:按照类型注入
Java类中引用类型的数据类型和spring容器中（配置文件）bean 的class 属性是同源关系的 如在一个包下
同源 就是一类的意思
1、Java类中引用类型 的数据类型和bean的class的值一样
2、Java类引用类型的数据类型和bean的class的值是父字关系
3、Java类引用类型的数据类型和bean的class的值是接口和实现类的关系
语法
<bean id = "myStudent" class = "Student的全路径名称" autowire = "byType">
基本数据类型的赋值
</bean>
<bean id = "myStudent" class = "Student的全路径名称" autowire = "byType">
<donstructor-arg name = "name" value = "张三"/>
<donstructor-arg name = "age" value = "20"/> name :构造方法的形参名
// <donstructor-arg index= "3" ref= "school"/>
ref：构造方法形参是引用类型
</bean>
<bean id = "school" class = "School的全路径名称" >
<property name = "name" value="清华"/>
</bean>
管理对各配置文件
多个配置文件： 一个模块一个文件
如 学生一个
班级一个
学习一个
语法
再创建一个主配置文件
<beans>
<import resource = ClassPath:其他配置文件的路径
</beans>
<beans>
<import resource = ClassPath:student.xml的路径
<import resource = ClassPath:student.xml的路径
</beans>
使用注解注入
通过注解完成对象的创建，代替xml
1、加入spring-context依赖
2、在类中创建注解
3、创建spring的配置文件
扫描器：指定注解在项目中的位置
4、使用注解创建对象，创建容器ApplicationContext
@Component(对象的名称也就是bean的id)
此注解创建对象 等同 bean的功能 等同于
位置：类的上面
@Component() 默认名称 类名的首字母小写 student
配置文件
配置扫描器：component - scan
base-package:注解在项目的包名
工作方法 ：spring扫码指定的包 找到注解 创建对象 赋值
三种方法
1、 <context：component-scan_base-package="包名1">
<context：component-scan_base-package="包名2">
2、<context：component-scan_base-package="包名1;包名2">
3、指定父包
<context：component-scan_base-package="父包名">
@Component("student")
public class Student(){
private String name;
private int age;
private School school； //引用数据类型
无参构造函数
有参的构造函数
private void setName(String name){
this.name = name;
}
private void setAge(int age){
this.age= age;
}
private void setschool(School school){
this.school= school;
}
}
其他创建对象的注解
这三个给项目分层
- @Repository() 用在持久层，dao的实现类上面 表示创建对象dao能访问数据库
- @Service（）业务层在service的实现类上，创建service对象，做业务处理，有事务等功能
- @Controller() 控制层：创建控制器对象，接收用户处理的参数，显示请求的结果
注解注入赋值
@Value(“张飞”) ：简单数据类型赋值
用在String 类型上，基本数据类型不OK 可以使用包装类
无需set方法
位置 参数上
@Value("李双")
private String name;
@Value("20")
private int age;
//引用数据类型
引用数据类型注解注入@Autowired
:自动注入原理 支持byName 、byType； 默认byType
位置：在属性的上面
属性：required = true 赋值失败程序报错
required = false 赋值失败正常执行、引用数据为null
@Autowired
private int age;
使用byName
在属性上加@Autowired
@Qualifier(value = “bean的id”)表示指定名称的bean完成赋值
@Autowired
@Qualifier("school")
private School school；
引用数据类型注解赋值@Resource
默认byName 失败用byType
位置参数上面
@Resource
private School school
--------------------AOP切面--------------------
动态代理
1、实现方法：jdk动态代理，使用jdk中的Proxy，Method，InvocaitonHanderl创建代理对象。
jdk动态代理要求目标类必须实现接口
2.动态代理的作用：
1）在目标类源代码不改变的情况下，增加功能。
2）减少代码的重复
3）解耦合。
步骤：
1、 定义一个接口
2、定义一个类ServiceTools 类中有共有的方法 （时间、事务）doLog();doTrans();
2、定义一个接口的实现类，继承接口 重新方法 doSome();
3、写代理类：
继承IncationHandler实现代理
public Class MyIncationHandler implement IncationHandler(){
private Object target;// 实现类
public MyIncationHandler(Object target){
this target = target;
}
public Object invoke(Object proxy,Method method, Object[] args)throws Throwable{
// 通过代理对象执行方法 会调用这个invoke()
Object res = null;
ServiceTools.doLog();
// 执行目标类的方法，通过Method类实现
res = method.invoke(target,args);//执行实现类的方法
ServiceTools.doTrans();
// 目标方法的执行结果
return res;
}
}
使用jdk实现代理
public class MyApp(){
public static void main(String[] args){
SomeService target = new 实现类；
// 创建InvocationHandler
InvocationHandler handler = new MyIncationHandler(target);
// 使用proxy创建代理
SomeService proxy = (SomeService)Proxy.newProxyInsstance{
target.getClass().getClassLoader(),
target.getClass().getInterFaces(),Handler);
// 调用handler中的invoke();
proxy.dosome();
}
}
}
aspectj实现AOP
步骤
1、新建maven项目
2、加入依赖
aspectj依赖
juint单元测试
3、创建目标类：接口和实现类
4、创建切面类：普通类
（1）在类上加入@Aspect
(2) 在类中的定义方法,方法就是切面执行的代码（事务、日志、时间等）
在方法上加入aspectj的通知注解。如@before
有需要则指定切入表达式
5、创建spring配置文件，声明对象，把对象交给IOC管理
（1）声明目标对象
（2）声明切面类对象
（3）声明aspectj框架中自动代理生成器标签
6创建测试类
接口`
public interface SomeService{
void doSome(String name,Integer age);
}
实现类
public class SomeServiceImpl implements SomeService {
@Override
public void doSome(String name,Integer age){
Sysotem.out.println("执行----------")
}
}
切面类
@Aspect
public class MyAspect{
方法要求
1、public
2、void
3、方法名自定义
4、方法可以有参数也可以无参数
5、@Before前置注解
1、属性 Value 切入表达式，表示切面的执行位置
2、位置 ：在方法的上面
@Before(value = "execution(public void 包下的实现类.doSome(String,Integer)")
public void myBefore(){
//切面的代码
Sysotem.out.println("时间----------")
}
}
配置文件
// 声明目标类（实现类）对象
<bean id = "someService" class = "路径名" />
// 声明切面类对象
<bean id = "myAspect" class = "全路径名" />
//声明aspectj框架中自动代理生成器标签
<aop:aspectj-autoproxy>
后置通知@AfterReturn()
要求
1、public
2、void
3、方法有参数 Object 方法名自定义
4、属性 1、value：切入点表达式
2、returning 自定义的变量，便是目标方法有返回值的
自定义的变量名必须和通知方法的形参一样
位置： 方法上面
切面类 中的方法
@@AfterReturn(value = "execution(public void 包下的实现类.doSome(String,Integer)",returning = "res")
public void myAfterReturn(Object res){
res 和,returning = "res一样
//切面的代码
Sysotem.out.println("时间----------")
环绕通知@Around
属性：value:切入表达式
位置：方法上方
特点
功能最强的通知
在目标方法前后都能加入切面类的代码
控制目标方法是否调用执行
修改原目标方法的执行结果，影响最后的调用结果
@Around(value = "execution(public void 包下的实现类.doSome(String,Integer)")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
// 实现环体通知
Object result = null;
Sysotem.out.println("方法前")
// 目标方法调用
result = pjp.proceed();
Sysotem.out.println("方法后")
// 返回目标方法的执行结果
return result;
}
转载：https://blog.csdn.net/qq_47848696/article/details/115838386
查看评论