spring

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对象变成了通过第三方去生产或获取特定对象的方式