Spring 入门

最新推荐文章于 2024-07-15 15:14:58 发布
最新推荐文章于 2024-07-15 15:14:58 发布
阅读量250 收藏
点赞数
分类专栏： String 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nanoapple/article/details/52291693
版权

示例

首先举个栗子，演示 Spring 的注入，项目工程视图如下
项目工程视图

定义一个Tutorial类

package com.ggli.aop.model;

public class Tutorial {
    private String name;
    private String url;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public void printName() {
        System.out.println("Tutorial name: " + this.name);
    }
    public void printUrl() {
        System.out.println("Tutorial url: " + this.url);
    }
    public void printThrowException() {
        throw new IllegalArgumentException();
    }
}

在关联 Spring 的 applicationContext.xml 中配置 bean

<?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="tutorial1" class="com.ggli.aop.model.Tutorial">
        <property name="name" value="Java Essential Training"/>
        <property name="url" value="https://www.lynda.com/Java-tutorials/Java-Essential-Training/377484-2.html"/>
    </bean>
    <bean id="tutorial2" class="com.ggli.aop.model.Tutorial">
        <property name="name" value="Overview of IDEs for Java"/>
        <property name="url" value="https://www.lynda.com/Development-Tools-tutorials/Overview-IDEs-Java/486760-2.html"/>
    </bean>
    <bean id="tutorial3" class="com.ggli.aop.model.Tutorial">
        <property name="name" value="Up and Running with Java Applications"/>
        <property name="url" value="https://www.lynda.com/Java-tutorials/Up-Running-Java-Applications/435790-2.html"/>
    </bean>
</beans>

使用 p 简化 bean 的属性赋值（convert to p-namespace）
首先，导入 p 的命名空间（不需要导入 xsi:schemaLocation）

xmlns:p="http://www.springframework.org/schema/p"

bean 定义就可以写为

<bean id="tutorial1" class="com.ggli.aop.model.Tutorial" 
p:name="Java Essential Training" p:url="https://www.lynda.com/Java-tutorials/Java-Essential-Training/377484-2.html"/>

新建一个单元测试类

import com.ggli.aop.model.Tutorial;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UnitTest {

    @Test
    public void testObject() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Tutorial tutorial = (Tutorial) context.getBean("tutorial1");
        System.out.println("------------------------------");
        tutorial.printName();
        tutorial.printUrl();
        System.out.println("------------------------------");

        try {
            tutorial.printThrowException();
        } catch (Exception e) {

        }
    }
}

静态工厂方法配置 bean

Java 程序源码

package com.ggli.aop.fatory;

import java.util.HashMap;
import java.util.Map;

public class StaticFactoryMethod {
    public static Map<String, Tutorial> map = new HashMap<String, Tutorial>();

    static {
        map.put("Alice", new Tutorial(
        "Java Essential Training",
        "https://www.lynda.com/Java-tutorials/Java-Essential-Training/377484-2.html"));
        map.put("Grace", new Tutorial(
        "Overview of IDEs for Java",
        "https://www.lynda.com/Development-Tools-tutorials/Overview-IDEs-Java/486760-2.html"));
    }

    public static Tutorial getTutorial(String key){
        return map.get(key);
    }
}

xml 配置

<!-- static factory method -->    
<bean id="tutorial" factory-method="getTutorial" class="com.ggli.aop.fatory.StaticFactoryMethod">
    <constructor-arg value="Alice" type="java.lang.String"></constructor-arg>
</bean>

实例工厂方法配置 bean

Java 程序源码

package com.ggli.aop.fatory;

import java.util.HashMap;
import java.util.Map;

public class InstanceFactoryMethod {
    public static Map<String, Tutorial> map = new HashMap<String, Tutorial>();

    static {
        map.put("Alice", new Tutorial(
        "Java Essential Training",
        "https://www.lynda.com/Java-tutorials/Java-Essential-Training/377484-2.html"));
        map.put("Grace", new Tutorial(
        "Overview of IDEs for Java",
        "https://www.lynda.com/Development-Tools-tutorials/Overview-IDEs-Java/486760-2.html"));
    }

    public static Tutorial getTutorial(String key){
        return map.get(key);
    }
}

xml 配置

<!-- instance factory method -->
<bean id="method" class="com.ggli.aop.fatory.InstanceFactoryMethod"/>
<bean id="tutorial" factory-bean="method" factory-method="getTutorial" class="com.ggli.aop.fatory.StaticFactoryMethod">
    <constructor-arg value="Alice"></constructor-arg>
</bean>

AOP

Spring AOP 相当于一个拦截器，当一个方法执行时，Spring能够拦截正在执行的方法，在方法执行前或后增加额外的功能和处理。

Spring AOP 支持4种类型的通知

TypeDescription
before advice在方法执行前执行
after returning advice在方法执行返回一个结果后执行
after throwing advice在方法执行中抛出异常时执行
around advice在方法执行前后和抛出异常时执行，综合了上述三种

下面分别介绍。

before advice

创建一个实现 MethodBeforeAdvice 接口的类，该类实现 before 方法，当被拦截的方法执行前，该 before 方法会被执行。

package com.ggli.aop.advice;

import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;

public class BeforeAdvice implements MethodBeforeAdvice {
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("[Before method] " + o.getClass().getName() + "." + method.getName() + "()");
    }
}

在 Spring 的 applicationContext.xml 中，创建BeforeAdvice类对应的 bean，以及一个代理的 bean
设置两个 property

  • target：设置要拦截的 bean
  • interceptorNames：设置作用于 proxy/target 上的通知
<?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="tutorial1" class="com.ggli.aop.model.Tutorial">
        <property name="name" value="Java Essential Training"/>
        <property name="url" value="https://www.lynda.com/Java-tutorials/Java-Essential-Training/377484-2.html"/>
    </bean>

    <bean id="beforeAdvice" class="com.ggli.aop.advice.BeforeAdvice"/>

    <bean id="proxy1" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="tutorial1"/>
        <property name="interceptorNames">
            <list>
                <value>beforeAdvice</value>
            </list>
        </property>
    </bean>
</beans>

after advice

创建一个实现 AfterReturningAdvice 接口的类，在被拦截的方法运行返回结果后将执行类中的 afterReturning 方法

package com.ggli.aop.advice;

import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;

public class AfterAdvice implements AfterReturningAdvice {
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("[After method] " + o1.getClass().getName() + "." + method.getName() + "()");
    }
}

修改 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="tutorial1" class="com.ggli.aop.model.Tutorial">
        <property name="name" value="Java Essential Training"/>
        <property name="url" value="https://www.lynda.com/Java-tutorials/Java-Essential-Training/377484-2.html"/>
    </bean>

    <bean id="beforeAdvice" class="com.ggli.aop.advice.BeforeAdvice"/>
    <bean id="afterAdvice" class="com.ggli.aop.advice.AfterAdvice"/>

    <bean id="proxy1" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="tutorial1"/>
        <property name="interceptorNames">
            <list>
                <value>beforeAdvice</value>
                <value>afterAdvice</value>
            </list>
        </property>
    </bean>
</beans>

after throwing advice

创建一个类实现 ThrowsAdvice 接口。

package com.ggli.aop.advice;
import org.springframework.aop.ThrowsAdvice;

public class ExceptionAdvice implements ThrowsAdvice {
    public void afterThrowing(IllegalArgumentException e) throws Throwable {
        System.out.println("[ExceptionAdvice] sends the regards: " + e.toString());
    }
}

修改 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="tutorial1" class="com.ggli.aop.model.Tutorial">
        <property name="name" value="Java Essential Training"/>
        <property name="url" value="https://www.lynda.com/Java-tutorials/Java-Essential-Training/377484-2.html"/>
    </bean>

    <bean id="beforeAdvice" class="com.ggli.aop.advice.BeforeAdvice"/>
    <bean id="afterAdvice" class="com.ggli.aop.advice.AfterAdvice"/>
    <bean id="exceptionAdvice" class="com.ggli.aop.advice.ExceptionAdvice"/>

    <bean id="proxy1" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="tutorial1"/>
        <property name="interceptorNames">
            <list>
                <value>beforeAdvice</value>
                <value>afterAdvice</value>
                <value>exceptionAdvice</value>
            </list>
        </property>
    </bean>
</beans>

around advice

创建一个类实现 MethodInterceptor 接口，需要在方法中执行 Object result = methodInvocation.proceed() 方法才能得到执行，否则方法不会执行。

package com.ggli.aop.advice;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class AroundAdvice implements MethodInterceptor {
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        try {
            System.out.println("[Around method] Before: " + methodInvocation.getMethod().getName());
            Object obj = methodInvocation.proceed();
            System.out.println("[Around method] After: " + methodInvocation.getMethod().getName());
            return obj;
        } catch (IllegalArgumentException e) {
            System.out.println("[Around method] Exception: " + methodInvocation.getMethod().getName());
            throw e;
        }
    }
}

修改 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="tutorial1" class="com.ggli.aop.model.Tutorial">
        <property name="name" value="Java Essential Training"/>
        <property name="url" value="https://www.lynda.com/Java-tutorials/Java-Essential-Training/377484-2.html"/>
    </bean>
    <bean id="tutorial2" class="com.ggli.aop.model.Tutorial">
        <property name="name" value="Overview of IDEs for Java"/>
        <property name="url" value="https://www.lynda.com/Development-Tools-tutorials/Overview-IDEs-Java/486760-2.html"/>
    </bean>
    <bean id="tutorial3" class="com.ggli.aop.model.Tutorial">
        <property name="name" value="Up and Running with Java Applications"/>
        <property name="url" value="https://www.lynda.com/Java-tutorials/Up-Running-Java-Applications/435790-2.html"/>
    </bean>

    <bean id="beforeAdvice" class="com.ggli.aop.advice.BeforeAdvice"/>
    <bean id="afterAdvice" class="com.ggli.aop.advice.AfterAdvice"/>
    <bean id="exceptionAdvice" class="com.ggli.aop.advice.ExceptionAdvice"/>
    <bean id="aroundAdvice" class="com.ggli.aop.advice.AroundAdvice"/>

    <bean id="proxy1" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="tutorial2"/>
        <property name="interceptorNames">
            <list>
                <value>beforeAdvice</value>
                <value>afterAdvice</value>
                <value>exceptionAdvice</value>
            </list>
        </property>
    </bean>
    <bean id="proxy2" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="tutorial3"/>
        <property name="interceptorNames">
            <list>
                <value>aroundAdvice</value>
            </list>
        </property>
    </bean>
</beans>

单元测试类

import com.ggli.aop.model.Tutorial;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UnitTest {

    @Test
    public void testObject() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Tutorial tutorial = (Tutorial) context.getBean("tutorial1");
        tutorial.printName();
        System.out.println("------------------------------");
        tutorial.printUrl();
        System.out.println("------------------------------");

        try {
            tutorial.printThrowException();
        } catch (Exception e) {

        }
    }

    @Test
    public void testAdvice() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Tutorial tutorial = (Tutorial) context.getBean("proxy1");
        tutorial.printName();
        System.out.println("------------------------------");
        tutorial.printUrl();

        try {
            tutorial.printThrowException();
        } catch (Exception e) {

        }
    }

    @Test
    public void testAround() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Tutorial tutorial = (Tutorial) context.getBean("proxy2");
        tutorial.printName();
        System.out.println("------------------------------");
        tutorial.printUrl();

        try {
            tutorial.printThrowException();
        } catch (Exception e) {

        }
    }
}
清水白石
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring经典面试题
weixin_43343469的博客
08-05 240
Spring经典面试题 一 Spring框架的理解 Spring 是一个企业级的开源框架，在项目中充当容器的角色，可以整合第三方的框架如Mybatis，Struts2 两大重要的部分，IOC和AOP IOC就是把对象的创建权反转给spring容器进行管理 AOP，面向切面编程，就是在不增加原有代码的基础上，去增加新的功能；比如过滤器，拦截器，声明式事务 二 Spring的优点 降低了...
Spring入门
行者无疆的博客
03-19 1825
1 Spring 简介 1.1 Spring 概述 官网定义： Spring 框架为任何类型的部署平台上的基于 Java 的现代企业应用程序提供了全面的编程和配置模型。 Spring 的一个关键元素是在应用程序级别的基础架构支持：Spring 专注于企业应用程序的 “管道”，以便团队可以专注于应用程序级别的业务逻辑，而不必与特定的部署环境建立不必要的联系。 慕课解释： 简单来说：Spring 是一个免费开源框架，为了简化企业级项目开发，提供全面的开发部署解决方案。 1.2 Spring 的体系结构 结构图
Spring入门教程
weixin_58642210的博客
12-12 1779
目录 工厂模式 1.什么是框架？ 2.Spring的优势 3.举个User小例子 IOC控制反转 beans 单例模式 工厂模式 把原来分布在各个地方的对象创建的过程都单独抽离出来，统一交给工厂类来负责所需对象的创建 1.什么是框架？ 1.1框架本身一般不完整 1.2在里面进行填充扩展，迎合公司的业务需求，做公司的项目 1.3为了更好的适合大多数项目，不断进行扩展，扩充的东西就是类库 2.Spring的优势 2.1方便解耦，简化开发 Spring就是一个大工厂，可以将所有..
Spring入门第一讲——Spring框架的快速入门
热门推荐
李阿昀的博客
04-08 14万+
Spring的概述什么是Spring据度娘所载： Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。 Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Exp
Spring概述与核心概念学习 -- Spring入门（一）
HHX_01的博客
04-24 1万+
Spring Framework 是一个功能强大的 Java 应用程序框架，旨在提供高效且可扩展的开发环境。它结合了轻量级的容器（IOC）和依赖注入(DI)功能，提供了一种使用 POJO 进行容器配置和面向切面的编程的简单方法，以及一组用于AOP(切面编程)的模块。Spring 框架还支持各种移动应用开发技术，如 Android 和 iOS。
Spring入门，看这篇就够了
m0_54928777的博客
06-17 3365
一篇对Spring入门案例演示的文章，仅供正在学习Spring的小伙伴们参考哟！
使用Eclipse 开发Spring入门程序
m0_46814663的博客
08-21 3166
在上述main方法中并没有使用new运算符创建TestDaoImpl类的对象，而是通过Spring容器来获取实现类对象，这就是IoC的工作机制。首先使用Eclipse创建一个Web应用（项目），将Spring的4个基础包和第三方依赖包commons-logging-1.2.jar复制到WEB-INF/lib目录中。1、打开文件：spring-framework-4.3.6.RELEASE>docs>spring-framework-reference>html>index.html。Spring解决的是。
Educoder Spring入门 第一关：Hello Spring
于建章的博客
10-01 2656
Spring入门
Spring入门学习推荐
我有明珠一颗的博客
05-11 4041
http://blog.csdn.net/soonfly/article/details/68498742该作者的 spring 相关博客都很好，我用来作为复习 Spring 基础的资料
IDEA环境配置及Spring入门
YouthBlood9的博客
09-13 2020
IDEA环境配置及Spring入门–以HelloWorld为例的简单介绍与开发步骤前言：本文主要内容一：IDEA环境配置二：用传统Java编程方式写HelloWorld例子传统java：不使用框架1.先构建一个新项目2.在新建的项目src下建立beans包，新建java class：HelloWorld、Main三：用Spring框架写HelloWorld例子1. 什么是Spring2. 开发步骤（基于IDEA）构建新项目分三步进行总结：对Spring的作用的初步了解参考文献 前言：本文主要内容 安装J
spring入门
12-23
让我们从这个"spring入门"的描述出发，深入探讨Spring的核心概念和技术。 1. **依赖注入（Dependency Injection，DI）**：Spring 的核心特性之一是依赖注入，它允许开发者在运行时将对象之间的依赖关系进行管理。...
Spring入门例子
04-14
Spring入门例子，只是实现了如何注入依赖，具体细节可以查看博客https://blog.csdn.net/qq_29924227/article/details/79942724
Spring入门经典
05-08
Beginning.Spring-Spring入门经典.pdf 学习 Spring 很好的入门书
Spring源码(三) Spring IoC之BeanFactory创建bean和获取bean
一生编程，快乐编程
07-11 951
bean 对象主要放在 map 里面，map 作为缓存。map 的key 是 bean对象的名称， value 是 bean 对象或者对象工厂。代码详情见： https://blog.csdn.net/sinat_32502451/article/details/140155044。详情见： https://blog.csdn.net/sinat_32502451/article/details/140247662。根据 bean 名称，返回已经注册的单例对象，如果没有注册，则创建并注册一个新对象。
springmvc1
benpaodeDD的博客
07-14 170
以前的servlet程序：
springboot start.aliyun.com java8
最新发布
JavaUpgrade
07-15 53
springboot 2.3.12.RELEASE alibaba cloud RDS alibaba cloud Redis alibaba cloud oss alibaba cloud sms alibaba cloud schedulerX spring cloud alibaba
Spring常见的自定义和扩展的方法
Casual_Lei的博客
07-12 232
通过类和@Bean方法，自定义Bean的创建过程。@Bean使用Spring AOP（Aspect-Oriented Programming）自定义注解和拦截方法调用。通过实现接口，在Bean的初始化前后添加自定义逻辑。@Component@Override@Override通过实现接口，可以在Bean定义加载后但在Bean实例化前修改Bean定义。@Component@Override通过实现接口，监听Spring应用上下文事件。
5.SpringBoot核心源码-启动类源码分析
流月up的博客
07-12 400
SpringBoot核心源码-启动类源码分析

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值