Spring学习笔记（20）----------Schema初步学习

最新推荐文章于 2022-08-25 05:24:03 发布
最新推荐文章于 2022-08-25 05:24:03 发布
阅读量134 收藏
点赞数
原文链接：https://my.oschina.net/sfsimon/blog/659426
版权

先来一个HelloWorld的简单例子，开开胃，爽一下~！

 

 

1、Aop配置文件spring-aop.xml

[html] view plain copy print ?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans  
  3.     xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xmlns:p="http://www.springframework.org/schema/p"  
  6.     xmlns:aop="http://www.springframework.org/schema/aop"  
  7.     xsi:schemaLocation=  
  8.         "http://www.springframework.org/schema/beans   
  9.         http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
  10.         http://www.springframework.org/schema/aop  
  11.         http://www.springframework.org/schema/aop/spring-aop-2.5.xsd  
  12.         ">  
  13.       
  14.     <bean id = "helloWorldServiceImpl" class="com.spring.xkey.aop.HelloWorldServiceImpl">  
  15.     </bean>  
  16.       
  17.     <bean id = "aspect" class = "com.spring.xkey.aop.HelloWorldAspect">  
  18.     </bean>  
  19.       
  20.     <aop:config>  
  21.         <aop:pointcut id="pointcut" expression="execution(* com.spring..*.sayHello(..)) and args(user)"/>  
  22.         <aop:aspect ref="aspect">  
  23.             <aop:before pointcut-ref = "pointcut" method="beforeAdvice(java.lang.String)" arg-names="user"/>  
  24.             <aop:after pointcut="execution(* com.spring..*.sayHello(..))" method="afterAdvice"/>  
  25.             <aop:after-returning pointcut="execution(* com.spring..*.sayAfterReturning(..))"   
  26.                                  method="afterReturningAdvice"  
  27.                                  arg-names="value"  
  28.                                  returning="value"/>  
  29.             <aop:after-throwing pointcut="execution(* com.spring..*.sayAfterThrowing(..))"  
  30.                                 method="afterThrowingAdvice"  
  31.                                 arg-names="e"  
  32.                                 throwing="e"/>  
  33.             <aop:around pointcut="execution(* com.spring..*.sayAround(..))"  
  34.                         method="aroundAdvice"  
  35.                         />  
  36.         </aop:aspect>  
  37.     </aop:config>  
  38. </beans>  
<?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:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation=
		"http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
		">
	
	<bean id = "helloWorldServiceImpl" class="com.spring.xkey.aop.HelloWorldServiceImpl">
	</bean>
	
	<bean id = "aspect" class = "com.spring.xkey.aop.HelloWorldAspect">
	</bean>
	
	<aop:config>
		<aop:pointcut id="pointcut" expression="execution(* com.spring..*.sayHello(..)) and args(user)"/>
		<aop:aspect ref="aspect">
			<aop:before pointcut-ref = "pointcut" method="beforeAdvice(java.lang.String)" arg-names="user"/>
			<aop:after pointcut="execution(* com.spring..*.sayHello(..))" method="afterAdvice"/>
			<aop:after-returning pointcut="execution(* com.spring..*.sayAfterReturning(..))" 
								 method="afterReturningAdvice"
								 arg-names="value"
								 returning="value"/>
			<aop:after-throwing pointcut="execution(* com.spring..*.sayAfterThrowing(..))"
								method="afterThrowingAdvice"
								arg-names="e"
								throwing="e"/>
			<aop:around pointcut="execution(* com.spring..*.sayAround(..))"
						method="aroundAdvice"
						/>
		</aop:aspect>
	</aop:config>
</beans>

2、HelloWorldService接口

[java] view plain copy print ?
  1. package com.spring.xkey.aop;  
  2.   
  3. public interface HelloWorldService {  
  4.   
  5.     public void sayHello(String username);  
  6.     public boolean sayAfterReturning();   
  7.     public void sayAfterThrowing();  
  8.     public int sayAround(String username,String password);  
  9. }  
package com.spring.xkey.aop;

public interface HelloWorldService {

	public void sayHello(String username);
	public boolean sayAfterReturning(); 
	public void sayAfterThrowing();
	public int sayAround(String username,String password);
}


3、HelloWorldServiceImpl类

[java] view plain copy print ?
  1. package com.spring.xkey.aop;  
  2. import java.lang.RuntimeException;  
  3.   
  4. public class HelloWorldServiceImpl  implements HelloWorldService{  
  5.     public void sayHello(String username){  
  6.         System.out.println("My first Aop test "+username);  
  7.     }  
  8.     public boolean sayAfterReturning(){  
  9.         System.out.println("after returning");  
  10.         return true;  
  11.     }  
  12.       
  13.     public void sayAfterThrowing(){  
  14.         System.out.println("After throwing");  
  15.         throw new RuntimeException();  
  16.     }  
  17.       
  18.     public int sayAround(String username,String password){  
  19.         System.out.println("Around::: "+username+", "+password);  
  20.         int val = 1;  
  21.         return val;  
  22.     }  
  23. }  
package com.spring.xkey.aop;
import java.lang.RuntimeException;

public class HelloWorldServiceImpl  implements HelloWorldService{
	public void sayHello(String username){
		System.out.println("My first Aop test "+username);
	}
	public boolean sayAfterReturning(){
		System.out.println("after returning");
		return true;
	}
	
	public void sayAfterThrowing(){
		System.out.println("After throwing");
		throw new RuntimeException();
	}
	
	public int sayAround(String username,String password){
		System.out.println("Around::: "+username+", "+password);
		int val = 1;
		return val;
	}
}


4、具体实现AOP编程的HelloWorldAspect类

[java] view plain copy print ?
  1. package com.spring.xkey.aop;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.ProceedingJoinPoint;  
  5.   
  6.   
  7. public class HelloWorldAspect {  
  8.       
  9.     public void beforeAdvice(String user){  
  10.         //System.out.println(jp.getArgs()[0].toString());  
  11.         System.out.println("before advice " + user);  
  12.     }  
  13.       
  14.     public void afterAdvice(JoinPoint jp){  
  15.         System.out.println("after advice "+jp.getArgs()[0].toString());  
  16.     }  
  17.       
  18.     public void afterReturningAdvice(Object value){  
  19.         System.out.println("afterReturning advice "+value);  
  20.           
  21.     }  
  22.     public void afterThrowingAdvice(Exception e){  
  23.         System.out.println("after throwing advice exception:" + e);   
  24.     }  
  25.       
  26.     public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable{  
  27.         /**System.out.println(pjp.toLongString()); 
  28.         System.out.println(pjp.getSignature().toString()); 
  29.         System.out.println(pjp.getKind().toString()); 
  30.         System.out.println(pjp.getArgs()[0].toString()); 
  31.         System.out.println("name+psd");*/  
  32.         Object [] obj = pjp.getArgs();  
  33.         String username = (String) obj[0];  
  34.         String password = (String) obj[1];  
  35.         System.out.println(username+","+password);  
  36.         Object retVal;  
  37.         if(username.equals("xkey") && password.equals("color")){  
  38.             retVal = pjp.proceed();  
  39.         }else{  
  40.             retVal = pjp.proceed(new Object[]{"ideal","*******"});  
  41.         }  
  42.         System.out.println("name+psd");  
  43.         if(retVal == null) System.out.println("false");  
  44.         else{  
  45.             System.out.println(retVal.toString());  
  46.         }  
  47.         return 2;  
  48.     }  
  49. }  
package com.spring.xkey.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;


public class HelloWorldAspect {
	
	public void beforeAdvice(String user){
		//System.out.println(jp.getArgs()[0].toString());
		System.out.println("before advice " + user);
	}
	
	public void afterAdvice(JoinPoint jp){
		System.out.println("after advice "+jp.getArgs()[0].toString());
	}
	
	public void afterReturningAdvice(Object value){
		System.out.println("afterReturning advice "+value);
		
	}
	public void afterThrowingAdvice(Exception e){
		System.out.println("after throwing advice exception:" + e); 
	}
	
	public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable{
		/**System.out.println(pjp.toLongString());
		System.out.println(pjp.getSignature().toString());
		System.out.println(pjp.getKind().toString());
		System.out.println(pjp.getArgs()[0].toString());
		System.out.println("name+psd");*/
		Object [] obj = pjp.getArgs();
		String username = (String) obj[0];
		String password = (String) obj[1];
		System.out.println(username+","+password);
		Object retVal;
		if(username.equals("xkey") && password.equals("color")){
			retVal = pjp.proceed();
		}else{
			retVal = pjp.proceed(new Object[]{"ideal","*******"});
		}
		System.out.println("name+psd");
		if(retVal == null) System.out.println("false");
		else{
			System.out.println(retVal.toString());
		}
		return 2;
	}
}


5、测试类

[java] view plain copy print ?
  1. package com.spring.xkey.aop;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class AopTest {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         // TODO Auto-generated method stub  
  13.         ApplicationContext context =  
  14.             new ClassPathXmlApplicationContext("com/spring/xkey/aop/spring-aop.xml");  
  15.         HelloWorldService hello = (HelloWorldService)context.getBean("helloWorldServiceImpl");  
  16.         hello.sayHello("xkey");  
  17.         System.out.println("===================================");  
  18. //      hello.sayAfterReturning();  
  19. //      System.out.println("===================================");  
  20. //      hello.sayAfterThrowing();  
  21. //      System.out.println("===================================");  
  22.         Object val = (Object)hello.sayAround("xkey", "colo");  
  23.         System.out.println(val.toString());  
  24.     }  
  25. }  
package com.spring.xkey.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AopTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext context =
			new ClassPathXmlApplicationContext("com/spring/xkey/aop/spring-aop.xml");
		HelloWorldService hello = (HelloWorldService)context.getBean("helloWorldServiceImpl");
		hello.sayHello("xkey");
		System.out.println("===================================");
//		hello.sayAfterReturning();
//		System.out.println("===================================");
//		hello.sayAfterThrowing();
//		System.out.println("===================================");
		Object val = (Object)hello.sayAround("xkey", "colo");
		System.out.println(val.toString());
	}
}


 

6、AOP Around（环绕通知）可以控制返回对象，即你可以返回一个与目标对象完全不同的返回值，虽然这很危险，但是你却可以办到。目标方法的返回值 就是 环绕通知的返回值。proceed() 方法可以在通知体内调用一次、多次 或根本不用调用；还可以控制执行方法的参数值。具体见aroundAdvice方法的实现。


7、给个更直观的结果

[java] view plain copy print ?
  1. before advice xkey  
  2. My first Aop test xkey  
  3. after advice xkey  
  4. ===================================  
  5. xkey,colo  
  6. Around::: ideal, ********  
  7. name+psd  
  8. In the AroundAdvice the return value is 1  
  9. After AroundAdvice modify return value is 2  
before advice xkey
My first Aop test xkey
after advice xkey
===================================
xkey,colo
Around::: ideal, ********
name+psd
In the AroundAdvice the return value is 1
After AroundAdvice modify return value is 2


 

这里使用AOP Around就可以用来进行一个身份验证，通过面向切面编程（AOP）将验证部分独立出来，使得代码的耦合度降低，如果使用面向对象思想（OOP）就应该是独立写一个身份验证的方法，然后当需要使用该方法再去new 一个身份验证方法的类，然后传递参数通过验证类中的方法去验证，这样代码的耦合度就变强了。


 

 

通过Scheme配置实现AOP步骤

   步骤一、编写业务类：

public class AspectBusiness {
   //切入点
    public String delete(String obj) {
        System.out.println("==========调用切入点：" + obj + "说：你敢删除我！===========\n");
        return obj + "：瞄～";
    }

    public String add(String obj) {
        System.out.println("================这个方法不能被切。。。============== \n");
        return obj + "：瞄～ 嘿嘿！";
    }

    public String modify(String obj) {
        System.out.println("=================这个也设置加入切吧====================\n");
        return obj + "：瞄改瞄啊！";
    }

}

步骤二、编写切面类：切面类中，包含了所有的通知

public class AspectAdvice {

     //前置通知
   public void doBefore(JoinPoint jp) {
        System.out.println("===========进入before advice============ \n");

        System.out.print("准备在" + jp.getTarget().getClass() + "对象上用");
        System.out.print(jp.getSignature().getName() + "方法进行对 '");
        System.out.print(jp.getArgs()[0] + "'进行删除！\n\n");

        System.out.println("要进入切入点方法了 \n");
    }


     // 后置通知
     // @param jp
     //            连接点
     // @param result
     //          返回值
    
    public void doAfter(JoinPoint jp, String result) {
        System.out.println("==========进入after advice=========== \n");
        System.out.println("切入点方法执行完了 \n");

        System.out.print(jp.getArgs()[0] + "在");
        System.out.print(jp.getTarget().getClass() + "对象上被");
        System.out.print(jp.getSignature().getName() + "方法删除了");
        System.out.print("只留下：" + result + "\n\n");
    }


     // 环绕通知
    // @param pjp
     //           连接点
   
    public object doAround(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("===========进入around环绕方法！=========== \n");

        // 调用目标方法之前执行的动作
        System.out.println("调用方法之前: 执行！\n");

        // 调用方法的参数
        Object[] args = pjp.getArgs();
        // 调用的方法名
        String method = pjp.getSignature().getName();
        // 获取目标对象
        Object target = pjp.getTarget();
        // 执行完方法的返回值：调用proceed()方法，就会触发切入点方法执行
        Object result = pjp.proceed();

        System.out.println("输出：" + args[0] + ";" + method + ";" + target + ";" + result + "\n");
        System.out.println("调用方法结束：之后执行！\n");
     return  result;
    }

 
     //异常通知
  
    public void doThrow(JoinPoint jp, Throwable e) {
        System.out.println("删除出错啦");
    }

}

步骤四、配置文件的编写：

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="    
          http://www.springframework.org/schema/beans    
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd    
          http://www.springframework.org/schema/context    
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/aop    
          http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"
    default->

    <!-- ==============================利用spring 利用aspectj来配置AOP================================ -->

    <!-- 声明一个业务类 -->
    <bean id="aspectBusiness" class="aop.schema.AspectBusiness" />

    <!-- 声明通知类 -->
    <bean id="aspectAdvice" class="aop.schema.advice.AspectAdvice" />

   <aop:config>
        <aop:aspect id="businessAspect" ref="aspectAdvice">
            <!-- 配置指定切入的对象 -->
            <aop:pointcut id="point_cut" expression="execution(* aop.schema.*.*(..))" />
            <!-- 只匹配add方法作为切入点
            <aop:pointcut id="except_add" expression="execution(* aop.schema.*.add(..))" />
             -->

            <!-- 前置通知 -->
            <aop:before method="doBefore" pointcut-ref="point_cut" />
            <!-- 后置通知 returning指定返回参数 -->
            <aop:after-returning method="doAfter"
                pointcut-ref="point_cut" returning="result" />
            <aop:around method="doAround" pointcut-ref="point_cut"/>
            <aop:after-throwing method="doThrow" pointcut-ref="point_cut" throwing="e"/>
        </aop:aspect>
    </aop:config>
</beans>

步骤五、测试类：

public class Debug {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("aop/schema_aop.xml");
        AspectBusiness business = (AspectBusiness) context.getBean("aspectBusiness");
        business.delete("猫");
    }

}

转载于:https://my.oschina.net/sfsimon/blog/659426

chunbo1110
关注
SpringCloud学习笔记-狂神说
weixin_44202871的博客
07-17 597
SpringBoot 微服务
Spring学习笔记9---spring和mybatis整合继承SqlSessionDaoSupport
weixin_45263852的博客
03-12 219
7.3.Spring-mybatis整合二 步骤： 编写实体类User 编写接口UserMapper 编写UserMapper.xml 编写UserMapperImpl2实现类 编写mybatis-config.xml配置文件 编写spring-dao.xml配置文件 编写applicationContent.xml 测试 1.在整合一的基础上，写入UserMapperImpl2类，实现UserMapper接口 import com.kuang.pojo.User; import org.apache.
Spring学习笔记(四)--spring配置文件schema约束
m0_67402588的博客
08-25 681
目前我们项目中用到的spring版本是5.0.2.RELEASE版本,打开spring-context:5.0.2.RELEASE.jar,打开其下的META-INF文件夹,这下边有两个重要的文件,spring.handlers和spring.schemas。3.xsi:schemaLocation:将命名空间和模式位置关联,提供了一个xml namespace到对应的xsd文件的一个映射,所以在xsi:schemaLocation后面配置的字符串都是成对的。4.使用别名引入多个schema文件。
利用AOP及Interceptor封装链路id、接口统一返回结果Result对象
大碍桃花开
11-07 1878
链路id封装实现及使用 现有模块在返回结果中统一封装了响应码code及响应信息msg, 遇到报错时通过报错信息无法快速定位到报错相关的日志信息，查看日志不是很方便 {code: “-1”, msg: “系统繁忙”, content: null} 封装链路id后，可根据此id作为关键字查找日志，日志信息中会包含整个请求中的相关日志，定位问题会方便很多 { “code”: “1”, “msg”: “success”, “content”: { “page”: 1, “pageSize”: 10, “tot
使用注解，返回统一数据格式
一路向前
12-21 1429
学习了，拼接的方式 返回统一格式的值，如果其它接口要添加了呢？ 这时候考虑用注解的方式（使用aop的切面）进行处理。 目录 注解： 定义一个注解类ResultRegister ResultRegistersAnalytic 实体类： AppResult PageData 分页 ResultCode 状态 统一返回值： ResultUtil 异常类： AjaxResult BusinessException ErrorEnum GlobalExcepti...
Spring笔记（三）:Aop详解
Flyer的后花园
09-01 1621
一、Aop原理 （一）动态代理 1、详见：java进阶（七）：详解JAVA代理 2、主要是Proxy 与 InvocationHandle r接口 （二）Cglib 实现 1、主要是 Enhancer 和 MethodInterceptor 接口 2、实现代码如下： [java] view plain copy  
Spring2.5.6学习笔记-最新
09-01
以上是 Spring 2.5.6 学习笔记中的关键知识点，通过这些基础知识的学习，开发者可以开始构建基于 Spring 框架的应用程序。接下来，可以进一步深入学习 Spring 的高级特性，如事务管理、安全性、Web 开发等方面的知识...
Spring学习笔记(16)----使用Spring配置文件实现AOP
03-17
在本篇Spring学习笔记中，我们将深入探讨如何利用Spring配置文件来实现面向切面编程（AOP）。面向切面编程是Spring框架的核心特性之一，它允许我们把关注点分离，将横切关注点（如日志、事务管理、权限控制等）与...
Spring Boot学习笔记--Day2
lp82lf的博客
06-25 886
Spring Boot 1.Spring Boot简介 Spring诞生时是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的 轻量级代替品。无需开发重量级的Enterprise JavaBean（EJB），Spring为企业级 Java开发提供了一种相对简单的方法，通过依赖注入...
Aop的使用(通知，日志存储等)
LC的博客
01-08 5416
AOP是面向切面的横向的编程，在不影响原来业务的基础上，实现动态的增强。 通知顺序： 先环绕放行前，前置，环绕放行后，后置@After，最终@AfterReturning（对方法的结果做处理） 一、实现AOP方式： 1.使用原生的spring API接口。 2.自定义类，把这个类作为切面，其中的方法在切点前或后执行。 二、具体操作 1.首先,要使用AOP需要导入包 <dependency> <groupId>org.aspectj</groupId> &
ProceedingJoinPoint获取实现类接口上的注解
shenyunsese的专栏
04-12 2万+
使用aspectj处理拦截aop，需要获取实现类接口上的注解 public Object around(ProceedingJoinPoint pjp) throws Throwable{ long time1=System.currentTimeMillis(); String className=pjp.getTarget().getClass().getS
编译期注解学习五 - ElementKind，TypeKind，不同Element类型判断
lidongxiu0714
07-28 2917
1 ElementKind 如何判断Element的类型呢，需要用到ElementKind，ElementKind为元素的类型，元素的类型判断不需要用instanceof去判断，而应该通过getKind()去判断对应的类型 类型 说明 PACKAGE 包 ENUM 枚举 CLASS 类 ANNOTATION_TYPE 注解 INTERFACE 接口 ENUM_CONSTANT 枚举常量 FIELD...
java有一个交通工具类vehicle_JAVA题 急求设计一个交通工具类Vehicle,它具有如下属性：...
weixin_32767591的博客
02-25 1046
匿名用户1级2014-05-29 回答publicclassVehicle{privateintspeed;privateStringkind;privateStringcolor;publicintgetSpeed(){returnspeed;}publicvoidsetSpeed(intspeed){this.speed=speed;}publicStr...
Java注解处理器
avclk66666的专栏
03-03 929
Java注解处理器 2015/03/03 | 分类：基础技术|0 条评论| 标签：注解 分享到：1 译文出处：race604.com原文出处：Hannes Dorfmann Java中的注解(Annotation)是一个很神奇的东西，特别现在有很多Android库都是使用注解的方式来实现的。一直想详细了解一下其中的原理。很有幸阅读到一篇详细解...
Spring框架之AOP
萌萌的PP博客
09-27 248
一.代理模式 1.静态代理模式                  实现静态代理三要素                          a.共同行为                          b.代理角色                                 与目标角色拥有共同行为                                 增强目标角色行为       ...
ProceedingJoinPoint获取当前方法
热门推荐
Meiyang1990的博客
01-22 7万+
aspectJ切面通过ProceedingJoinPoint想要获取当前执行的方法： 错误方法：      Signature s = pjp.getSignature();     MethodSignature ms = (MethodSignature)s;     Method m = ms.getMethod(); 这种方式获取到的方法是接口的方法而不是具体的实现类
Aspectj的JointPoint对象详解
Isaac Lin
04-13 4508
JointPoint有很多方法，下面将介绍其常用的一些方法。 getArgs 获取切入点的参数。示范如下： @Before("myPointCut()") public void myBefore(JoinPoint joinPoint) { Object[] objects = joinPoint.getArgs(); System.out....
电子商务之价格优化算法：动态定价：动态定价的实施与案例研究.docx
最新发布
11-05
电子商务之价格优化算法：动态定价：动态定价的实施与案例研究.docx
Spring学习笔记：配置、schema与bean管理
本文档是关于Spring框架学习笔记的重点内容，主要围绕Spring容器的初始化、配置文件处理、schema文件管理以及bean的生命周期管理展开。首先，介绍了两种常见的Spring容器实例化方式：一是通过类路径下的配置文件，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值