spring快速上手

一、基础概念

1.使用spring后，被spring管理的类，不需要再new。

2.要想类被spring管理，则需要通过bean的方式，把类引入到spirng的配置文件中。

二、导入spring框架

导入spring依赖

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <spring.version>4.0.1.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.2</version>
        </dependency>
    </dependencies>

在资源目录下创建spring-config.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"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

</beans>

三、第一个IOC

创建一个实体类User

// 省略了getset
public class User {
    private int uid;
    private String uname;
    private String upassword;
}

注册bean

    <bean id="zhangsan" class="com.pojo.User">
        <property name="uname" value="张三"/>
        <property name="upassword" value="123"/>
    </bean>

测试

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
    User user = (User) context.getBean("zhangsan");
    System.out.println(user.getUname());
}

四、第一个AOP

AOP的理解：

• 将复杂的需求分解出不同方面，将散布在系统中的“公共功能”“集中解决”
• 采用代理机制组装起来运行，在“不改变原程序”的基础上对代码段进行增强处理，增加新的功能

1、创建增强类

package com.advice;

public class LoggerAdvice {
    public void before(){
        System.out.println("LoggerAdvice.before()");
    }
}

2、创建要切入的业务类

package com.service;

public class UserService {
    public void login() {
        System.out.println("login");
    }
}

3、注册到spring中和配置切面

<bean id="userService" class="com.service.UserService"></bean>

<bean id="loggerAdvice" class="com.advice.LoggerAdvice"/>

<aop:config>
    <aop:pointcut id="pointcut" expression="execution(* com.service.*.*(..))"/>
    <aop:aspect ref="loggerAdvice">
        <aop:before method="before" pointcut-ref="pointcut"/>
    </aop:aspect>
</aop:config>

五、IOC扩展

package com.printor;

public interface Ink {
    public void show();
}

package com.printor;

public class InkColor implements Ink{
    @Override
    public void show() {
        System.out.println("彩色");
    }
}

package com.printor;

public interface Paper {
    public void show();
}

package com.printor;

public class PaperA4 implements Paper{
    @Override
    public void show() {
        System.out.println("A4纸");
    }
}

package com.printor;

public class PaperB5 implements Paper{
    @Override
    public void show() {
        System.out.println("B5");
    }
}

package com.printor;

public class HPPrintor {
    private Ink ink;
    private Paper paper;

    public void print(String content) {
        System.out.println("HP打印机打印内容：" + content);
        this.ink.show();
        this.paper.show();
    }

    public Ink getInk() {
        return ink;
    }

    public void setInk(Ink ink) {
        this.ink = ink;
    }

    public Paper getPaper() {
        return paper;
    }

    public void setPaper(Paper paper) {
        this.paper = paper;
    }
}

将以上的类，注册到spring中

    <bean id="inkColor" class="com.printor.InkColor"></bean>
    <bean id="paperA4" class="com.printor.PaperA4"></bean>
    <bean id="paperB5" class="com.printor.PaperB5"></bean>
    <bean id="hpPrintor1" class="com.printor.HPPrintor">
        <property name="ink" ref="inkColor"/>
        <property name="paper" ref="paperA4"/>
    </bean>
    <bean id="hpPrintor2" class="com.printor.HPPrintor">
        <property name="ink" ref="inkColor"/>
        <property name="paper" ref="paperB5"/>
    </bean>

通过注解实现

<context:component-scan base-package="com.printor"></context:component-scan>

InkColor、PaperA4、PaperB5、HPPrintor类上增加@Component注解

@Component
public class HpPrintor {
    @Autowired
    private Ink ink;
    @Autowired
    @Qualifier("paperA4")
    private Paper paper;
}

六、AOP扩展

使用注解实现

    <context:component-scan base-package="com.service"></context:component-scan>
    <aop:aspectj-autoproxy/>

package com.advice;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Aspect
@Component
public class PrintAdvice {

    @Pointcut("execution(* com.service.*.*(..))")
    public void pointcut(){

    }

    @Before("pointcut()")
    public void before(JoinPoint joinPoint) {
        System.out.println("打印前");
        String target = joinPoint.getTarget().toString(); // 类
        String method = joinPoint.getSignature().getName(); // 方法
        String args = Arrays.toString(joinPoint.getArgs()); // 参数列表

        System.out.println(target);
        System.out.println(method);
        System.out.println(args);
    }
    @After("pointcut()")
    public void after() {
        System.out.println("打印后");
    }
    @AfterReturning(pointcut = "pointcut()",returning = "ret")
    public void afterReturning(JoinPoint joinPoint, Object ret) {
        System.out.println("打印成功");
    }
    @AfterThrowing(pointcut = "pointcut()",throwing = "e")
    public void afterThrowing(Exception e) {
        System.out.println("打印失败");
    }
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) {
        System.out.println("打印中");
        Object result = null;
        try {
            // 执行目标方法
            result = joinPoint.proceed();
            // 返回通知逻辑
            System.out.println("After method execution, result: " + result);
        } catch (Exception e) {
            // 异常通知逻辑
            System.out.println("Exception occurred: " + e.getMessage());
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            // 后置最终通知，无论是否发生异常都会执行
            System.out.println("Finally block executed");
            return result;
        }
    }
}