spring自学入门
一.spring的基础配置
1.基础依赖引入
spring依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
junit依赖
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
2.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
https://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>
二.控制反转IOC(Inversion ofControl)是一种设计思想
1.过去的方式
在平常写代码中(以Users为例),先写Users实体类,然后在测试中直接实体化,然后调用users.toString()打印出来;
Users实体类
public class Users {
private int ID;
private String name;
public void setID(int ID) {
this.ID = ID;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Users{" +
"ID=" + ID +
", name='" + name + '\'' +
'}';
}
}
测试
public class DemoTest {
@Test
public void oldTest() {
Users users = new Users();
users.setName("sai");
users.setID(111);
System.out.println(users.toString());
}
}
缺点:
总之,不论我们写接口implements还是写类extends,如果想要创建或者修改都要去测试类中的方法内部修改, 当代码量大时极其容易混乱,因此IOC就出现了,由spring替我们创建对象,进行统一管理
###2.spring的方式
Users类依然不变,创建applicationContext.xml
<bean class="com.sai.demo.Users" id="users">
<property name="ID" value="123456"/>
<property name="name" value="sai"/>
</bean>
bean中的class指向实体类,取名为users;
在bean中实体化,输入ID和name;
测试类
public class DemoTest {
@Test
public void userTest(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Users users = context.getBean("users",Users.class);
System.out.println(users.toString());
}
}
new ClassPathXmlApplicationContext -----> 用context链接applicationContext.xml;
得到bean后用users链接实体类,实现实体类中的toString()方法
注解开发就是添加更多的依赖,以更加便捷的方式创建bean,但使用xml可以更加详细的配置,根据需求使用不同的方式
三.AOP面向切面编程
1.AOP的作用
提供声明式事务；允许用户自定义切面
横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 ....
切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知 执行的 “地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。
2.基础依赖
比IOC多了一个AOP织入
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.5</version>
</dependency>
3.编写顺序
UserService接口
public interface UserService {
public void printf();
}
UserServiceImpl实体类
public class UserServiceImpl implements UserService{
@Override
public void printf() {
System.out.println("实现AOP~");
}
}
在applicationContext.xml中注册UserServiceImpl实体类的bean
<!-- 注册bean-->
<bean id="userService" class="com.sai.service.UserServiceImpl"/>
编写切入类Log和AfterLog(从前后切入)
public class Log implements MethodBeforeAdvice {
//method : 要执行的目标对象的方法
//objects : 被调用的方法的参数
//Object : 目标对象
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName()+"的"+method.getName()+"方法被执行中");
}
}
public class AfterLog implements AfterReturningAdvice {
//returnValue 返回值
//method被调用的方法
//args 被调用的方法的对象的参数
//target 被调用的目标对象
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("执行了"+target.getClass().getName()+"的"+method.getName()+"方法,返回值:"+returnValue);
}
}
在applicationContext.xml中注册Log和AfterLog的bean
<!-- 注册bean-->
<bean id="log" class="com.sai.log.Log"/>
<bean id="afterLog" class="com.sai.log.AfterLog"/>
在applicationContext.xml中设置aop
<!-- AOP设置-->
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* com.sai.service.UserServiceImpl.*(..))"/>
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
测试类
public class AOPTest {
@Test
public void aopTest(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userService", UserService.class);
userService.printf();
}
}
运行截图
四.总结
以上所举的例子IOC和AOP是最简单的例子,方式有很多,重要的是理解spring的思想
尤其是IOC,控制反转是spring框架的核心内容,从以前的主动new对象变成了通过第三方去生产或获取特定对象的方式