spring学习笔记 -- day04 基于注解的配置

最新推荐文章于 2024-04-15 20:50:14 发布
最新推荐文章于 2024-04-15 20:50:14 发布
阅读量318 收藏
点赞数
分类专栏： ssh框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wingzhezhe/article/details/77155505
版权

一、环境搭建

1、创建web项目导入jar包

注意：基于注解的配置需要导入aop的支持包：spring-aop-4.2.4.RELEASE.jar



2、创建spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!-- 导入约束：
	除了要导入第一天的约束之外，还要导入context的名称空间和约束
-->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       					   http://www.springframework.org/schema/beans/spring-beans.xsd
       					   http://www.springframework.org/schema/context 
       					   http://www.springframework.org/schema/context/spring-context.xsd">

</beans>

3、使用@Component注解配置管理的资源

@Component

        它就相当于在配置文件中配置了一个bean标签。

        value属性用于指定bean的id

        如果没有指定value属性，bean的id就是当前类的名称，首字母改小写。

import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;

import cn.itcast.dao.ICustomerDao;
/**
 * 客户的持久层实现类
 *
 * <bean id="customerDao" class="cn.itcast.dao.impl.CustomerDaoImpl"></bean>
 * 
 * @Component
 * 		它就相当于在配置文件中配置了一个bean标签。
 * 		value属性用于指定bean的id
 * 		如果没有指定value属性，bean的id就是当前类的名称，首字母改小写。
 * 		<bean id="customerDaoImpl" class="cn.itcast.dao.impl.CustomerDaoImpl"></bean>
 */
@Repository(value="customerDao1")
public class CustomerDaoImpl implements ICustomerDao {

	@Override
	public void saveCustomer() {
		System.out.println("保存了客户。。。。。11111111111111111111111");
	}

}

4、在spring配置文件中开启对注解的支持

	<!-- 告知spring，在创建容器时，要扫描的包 -->
	<context:component-scan base-package="cn.itcast"></context:component-scan>

5、读取配置文件，创建对象

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

import cn.itcast.service.ICustomerService;
import cn.itcast.service.impl.CustomerServiceImpl;

public class Client {

	public static void main(String[] args) {
		//1.获取Spring容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		ICustomerDao cs1 = (ICustomerDao) ac.getBean("customerDao1");
		System.out.println(cs1);
	}

}

二、常用的注解

1、用于创建对象的注解

相当于：<bean id="" class="">

@Component

         作用：把资源让spring来管理。相当于在xml中配置一个bean。

         属性：value：指定bean的id。如果不指定value属性，默认bean的id是当前类的类名。首字母小写。

@Controller  @Service  @Repository

        他们三个注解都是针对一个的衍生注解，他们的作用及属性都是一模一样的。 他们只不过是提供了更加明确的语义化。

         @Controller：一般用于表现层的注解。

         @Service：一般用于业务层的注解。

         @Repository：一般用于持久层的注解。

细节：如果注解中有且只有一个属性要赋值时，且名称是value，value在赋值是可以不写。

2、用于注入数据的注解

相当于：<property name="" ref="">     <property name="" value="">

@Autowired

        作用：

                自动按照类型注入。当使用注解注入属性时，set方法可以省略。它只能注入其他bean类型。当有多个类型匹配时，使用要注入的对象变量名称作为bean的id，在spring容器查找，找到了也可以注入成功。找不到就报错。

@Qualifier

        作用：

                在自动按照类型注入的基础之上，再按照Bean的id注入。它不能独立使用，必须和@Autowire一起使用。

        属性：

                value：指定bean的id。

@Resource

        作用：

                直接按照Bean的id注入。它也只能注入其他bean类型。

        属性：

                name：指定bean的id。

@Value

        作用：

                注入基本数据类型和String类型数据的

        属性：

                value：用于指定值

public class CustomerServiceImpl implements ICustomerService {
	
	/**用于注入其他bean类型的
	 * 	@Autowired
	 * 		作用：自动按照类型注入。set方法可以不写。
	 * 			 如果没有匹配的类型，则报错。
	 *   		如果有多个匹配的情况，它会使用变量的名称作为bean的id，如果能找到，依然可以注入成功。如果再找不到，就报错。
	 * 	@Qualifier
	 * 		作用：在自动按类型注入的基础之上，再按照bean的id注入
	 * 
	 * 	@Resource
	 * 		作用：直接按照bean的id注入。
	 * 
	 * 用于注入基本数据类型
	 * 	@Value
	 * 		作用：注入基本类型和String类型数据
	 * 
	 */
//	@Autowired
//	@Qualifier(value="customerDao1")	
	@Resource(name="customerDao2")
	private ICustomerDao customerDao;
	
	@Value(value="com.mysql.jdbc.Driver")
	private String driver;
	@Value(value="jdbc:mysql://localhost:3306/spring_day02")
	private String url;
	@Value(value="root")
	private String username;
	@Value(value="1234")
	private String password;
	
	
	
	@Override
	public void saveCustomer() {
		System.out.println(driver);
		System.out.println(url);
		System.out.println(username);
		System.out.println(password);
		customerDao.saveCustomer();
	}

	/**
	* Autowired 注解的实现原理
	*
	*/
	public static void main(String[] args) {
		Class clazz = CustomerServiceImpl.class;
		Field[] fs = clazz.getDeclaredFields();
		for(Field f : fs){
			boolean b = f.isAnnotationPresent(Autowired.class);
			if(b){
				Class c = f.getType();
				System.out.println(c);
			}
		}
	}
}

3、用于改变作用范围的注解

@Scope
        作用：
                指定bean的作用范围。
        属性：
                value：指定范围的值。
        取值：

                singleton  

                prototype 

                request 

                session 

                globalsession

4、与生命周期相关的注解

相当于：<bean id="" class="" init-method="" destroy-method="" />

@PostConstruct

        作用：

                用于指定初始化方法。

@PreDestroy

        作用：

                用于指定销毁方法。

5、代码演示

业务层代码：
/**
 * 客户的业务层接口
 * @author zhy
 */
public interface ICustomerService {	
	/**
	 * 保存客户
	 * @param customer
	 */
	void saveCustomer();	
}


/**
 * 客户的业务层实现类
 * @author zhy
 * 
 */
//作用就相当于在xml中配置了一个bean标签，该注解有value属性，含义是bean的id。
//不写的时候，默认的id是：当前类名，且首字母小写。即：customerServiceImpl
@Component(value="customerService")
@Scope(value="singleton")
public class CustomerServiceImpl implements ICustomerService {
//	自动按照数据类型注入，拿着当前变量的数据类型在spring的容器中找，找到后，给变量赋值。
//	当有多个类型匹配时，会使用当前变量名称customerDao作为bean的id，继续在容器中找。
//	找到了，也能注入成功。找不到就报错。
//	@Autowired
//	@Qualifier(value="customerDao2")//在自动按照类型注入的基础之上，再按照id注入
	@Resource(name="customerDao2")//直接按照bean的id注入
	private ICustomerDao customerDao = null;
	
	@Value("com.mysql.jdbc.Driver")//注入基本类型和String类型数据
	private String driver;

	@Override
	public void saveCustomer() {
		System.out.println(driver);
		customerDao.saveCustomer();	
	}
}


持久层代码：
/**
 * 客户的持久层接口
 * @author zhy
 */
public interface ICustomerDao {
	/**
	 * 保存客户
	 */
	void saveCustomer();
}



/**
 * 客户的持久层实现类11111111111111111111
 * @author zhy
 *
 */
@Repository("customerDao1")
public class CustomerDaoImpl implements ICustomerDao {

	@Override
	public void saveCustomer() {
		System.out.println("保存了客户111111111111111111");
	}
}

/**
 * 客户的持久层实现类222222222222222222222222
 * @author zhy
 *
 */
@Repository("customerDao2")
public class CustomerDaoImpl2 implements ICustomerDao {

	@Override
	public void saveCustomer() {
		System.out.println("保存了客户2222222222222222222");
	}
}

测试类代码:
public class Client {
	public static void main(String[] args) {
		//1.获取容器
		ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
		//2.根据id获取对象
		ICustomerService cs = (ICustomerService) ac.getBean("customerService");				cs.saveCustomer();
	}
}

配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<!-- 我们导入约束时，除了昨天的那部分之外，还要单独导入一个context名称空间 -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       		  http://www.springframework.org/schema/beans/spring-beans.xsd
       		  http://www.springframework.org/schema/context 
       		  http://www.springframework.org/schema/context/spring-context.xsd">
	<!-- 告知spring框架在通过读取配置文件创建容器时，扫描的包，并根据包中类的注解创建对象-->
	<context:component-scan base-package="com.itheima"></context:component-scan>
</beans>

6、关于xml和注解的选择的配置

注解的优势：

        配置简单，维护方便（我们找到类，就相当于找到了对应的配置）。

XML的优势：

        修改时，不用改源码。不涉及重新编译和部署。

三、spring的纯注解配置

1、配置注解类 -- 配置要扫描注解的包

package cn.itcast.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;

/**
 * 此类就是一个配置类，用于让spring读取该类上的注解用的
 * 
 * @Configuration
 * 	作用：告知spring此类是一个配置类
 * @ComponentScan
 * 	作用：指定spring在创建容器时要扫描的包
 * 	属性：
 * 		value:指定要扫描的包名称。作用和basePackages是一模一样的。
 */
@Configuration
@ComponentScan({"cn.itcast"})
public class Configuration_A {
}

2、测试类

import javax.sql.DataSource;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import cn.itcast.config.Configuration_A;

public class Client {

	public static void main(String[] args)throws Exception {
		//1.获取Spring容器,参数是配置类的字节码文件
		ApplicationContext ac = new AnnotationConfigApplicationContext(Configuration_A.class);
		ICustomerService cs1 = (ICustomerService) ac.getBean("customerService");
		cs1.saveCustomer();

	}

}

3、引入其他配置类的做法

@Import

（1）、被引入的配置类

package cn.itcast.config;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;

import com.mchange.v2.c3p0.ComboPooledDataSource;

/**
 * @author winghze
 */
@Component("jdbcConfig")
public class JDBCConfig {
	
	@Value("com.mysql.jdbc.Driver")
	private String driver;
	
	@Value("jdbc:mysql://localhost:3306")
	private String url;
	
	@Value("root")
	private String username;
	
	@Value("1234")
	private String password;
	
	


	/**
	 * 用于创建一个C3P0连接池
	 * @return
	 * @throws Exception
	 * 
	 *  		
	 */
	public DataSource createDataSource() throws Exception{
		ComboPooledDataSource ds = new ComboPooledDataSource();
		ds.setDriverClass(driver);
		ds.setJdbcUrl(url);
		ds.setUser(username);
		ds.setPassword(password);	
		return ds;
	}
}

（2）、引入配置类的配置类

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;

/**
 * 此类就是一个配置类，用于让spring读取该类上的注解用的
 * @author zhy
 * 
 * @Configuration
 * 	作用：告知spring此类是一个配置类
 * @ComponentScan
 * 	作用：指定spring在创建容器时要扫描的包
 * 	属性：
 * 		value:指定要扫描的包名称。作用和basePackages是一模一样的。
 * @Import
 * 	作用：导入其他带有注解的类
 */
@Configuration
@ComponentScan({"cn.itcast"})
@Import({JDBCConfig.class})
//@PropertySource("classpath:/cn/itcast/config/jdbc.properties")
public class Configuration_A {
}

（3）、测试类

import javax.sql.DataSource;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import cn.itcast.config.Configuration_A;

public class Client {

	public static void main(String[] args)throws Exception {
		//1.获取Spring容器
		ApplicationContext ac = new AnnotationConfigApplicationContext(Configuration_A.class);
		JDBCConfig jc = (JDBCConfig) ac.getBean("jdbcConfig");
		DataSource ds = jc.createDataSource();
		System.out.println(dc.getConnection());
		
	}

}

4、spring3以后的新注解说明

@Configuration

        作用：

                用于指定当前类是一个配置类，相当于把当前类看成是配置文件，会从该类上加载注解。读取该类上@ ComponentScan注解初始化spring容器。

@ComponentScan

        作用：

                用于指定spring在初始化容器时要扫描的包。

        属性：

                basePackages：用于指定要扫描的包。和该注解中的value属性作用一样。

@PropertySource

        作用：

                用于加载.项目下的properties文件中的配置

        属性：

                value[]：用于指定properties文件位置。如果是在类路径下，需要写上classpath；

示例代码：

（1）、配置文件类

@Configuration
@ComponentScan(basePackages = "cn.itcast.spring")
@PropertySource("classpath:info.properties")//加载类路径下的properties文件
public class Configuration_A {
}

（2）、实体类

@Component("car")
public class Car {
	private String id ; 
	@Value("${car.name}")//此时是读取properties文件，根据key取value了。
	private String name ;
	@Value("${car.price}")//此时是读取properties文件，根据key取value了。
	private Double price ;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	@Override
	public String toString() {
		return "Car [id=" + id + ", name=" + name + ", price=" + price + "]";
	} 
}

（3）、properties配置文件

car.name = \u4FDD\u65F6\u6377//中文是保时捷
car.price = 1000000

@Import

        作用：

                用于导入其他配置类

        属性：

                value[]：用于指定其他配置类的字节码。

示例代码：

（1）、配置类

@Configuration
@ComponentScan(basePackages = "cn.itcast.spring")
@Import({ Configuration_B.class})
public class Configuration_A {
}

@Configuration
@PropertySource("classpath:info.properties")
public class Configuration_B {

}

@Bean

        作用：

                该注解只能写在方法上，表明使用此方法创建一个对象，并且交给spring管理。简单理解为，创建对象的由自己控制，但是创建完成的对象交给spring来管理，可以使用getBean()方法获取自己创建的对象。

        属性：

                name：给当前@Bean注解方法创建的对象指定一个名称(即bean的id）。

示例代码：

@Bean(name = "datasource2")
	public DataSource createDS() throws Exception {
		ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
		comboPooledDataSource.setUser("root");
		comboPooledDataSource.setPassword("1234");
		comboPooledDataSource.setDriverClass("com.mysql.jdbc.Driver");
		comboPooledDataSource.setJdbcUrl("jdbc:mysql:///spring_ioc");
		return comboPooledDataSource;
	}


DJTUDaker
关注
专栏目录
Spring Boot学习笔记--Day2
lp82lf的博客
06-25 883
Spring Boot 1.Spring Boot简介 Spring诞生时是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的 轻量级代替品。无需开发重量级的Enterprise JavaBean（EJB），Spring为企业级 Java开发提供了一种相对简单的方法，通过依赖注入...
framework学习笔记day07---Spring基础
Wynb1020的博客
12-27 374
新注解说明 @configuration @ComponenScan @Bean @PropertySource @Import Spring纯注解开发 注解开发的作用和弊端 AOP 概述 AOP原理环境搭建 动态代理之JDKProxy 动态代理之CGLIB
Spring 基于注解的配置
随风而逝的博客
07-08 172
基于注解的配置 从 Spring 2.5 开始就可以使用注解来配置依赖注入。而不是采用 XML 来描述一个 bean 连线，你可以使用相关类，方法或字段声明的注解，将 bean 配置移动到组件类本身。 在 XML 注入之前进行注解注入，因此后者的配置将通过两种方式的属性连线被前者重写。 注解连线在默认情况下在 Spring 容器中不打开。因此，在可以使用基于注解的连线之前，我们将需要在我们的...
基于注解的配置
ZKaTT的博客
11-02 170
Spring容器启动三要素：Bean的定义，Bean的实现，Spring容器   在基于xml文档配置bean时，Bean的定义与实现是分开的 而采用注解配置时，Bean的定义通过在Bean的实现类上标注注解实现。   使用注解定义Bean @Component 用于任何层次 @Service 用于对Service实现类进行标注 @Controller 用于对Controlle
Spring基于注解的配置
SHANLI_的博客
09-17 158
Spring @Required注解 @Required注释使用在Bean属性中的setter方法，表示该属性必须要在xml文件中进行配置，否则会抛出一个 BeanInitializationException 异常 Spring @Autowired注解 @Autowired 注释可以在 setter 方法中被用于自动连接 bean，一个属性或者任意命名的可能带有多...
spring-基于注解的配置
anjl1296的博客
09-30 103
基于注解的配置 除了采用采用xml来配置bean之外，也可以采用注解的方式来定义，注册，加载bean。 注解的方式在spring中默认时不开启的，所以需要在xml文件中进行配置启用 注解的启动方式有下面两种配置： 下面的配置既可以在所有类中启用注解 <context:annotation-config/> 还可以在部分你需要的类中启用注解，这个可以包含一些...
spring-3-基于注解的配置
qq_20466211的博客
12-19 169
参考什么是spring，它能够做什么? 参考w3cschool 参考Spring框架入门教程 1 基于注解的装配 在 Spring 中，尽管可以使用XML配置文件实现Bean的装配工作，但如果应用中Bean的数量较多，会导致XML配置文件过于臃肿，从而给维护和升级带来一定的困难。 Java从JDK 5.0以后，提供了Annotation(注解)功能，Spring 2.5版本开始也提供了对Annotation技术的全面支持，我们可以使用注解来配置依赖注入。 Spring默认不使用注解装配Bean， 因此需要在
Spring学习04----JDBCTemplate和事务控制
LLturn的博客
07-27 310
文章目录1.Spring中的事务控制 1.Spring中的事务控制
【Day 01 】学习笔记-Springboot仿牛客网论坛实现
Eurus1209的博客
05-22 439
新手学习仿牛客网论坛实现 文章目录新手学习仿牛客网论坛实现前言spring 容器管理bean管理对象的编程思想ioc - 控制反转依赖注入 前言 跟着牛客教学视频 学习 参杂八股文复习和基础知识笔记 spring 容器管理bean 管理对象的编程思想 ioc - 控制反转 自己管理对象时：new a new b a=b 缺点是 ab耦合 ioc 减少项目之间的耦合度 用 ioc 容器 实现依赖注入 ###aop -面向切面 底层不止启动tomcat 自动创建spring 容器 （在web项目中
Spring高级注解-Day3
m0_63176399的博客
10-29 214
//用于配置当前方法是一个前置通知 @Before(“execution(* com.example.service.impl..(…))”) public void printLog(){ System.out.println(“打印日志”); } } LogUtil.java @Component @Aspect public class EfficiencyUtils { private Long time; @Before(“execution(* com.example.service.impl.
Bean基于注解的配置
k7c9。
03-24 610
下面是一个使用注解定义一个DAO的Bean： import org.springframework.stereotype.Component; @Component("bookDao") public class BookDao { } 它相当于： &lt;bean id="bookDao" class="com.dao.bookDao" /&gt; @Component可以被S...
java注解配置_Spring 基于注解的配置
weixin_40005373的博客
02-15 194
从 Spring 2.5 开始就可以使用注解来配置依赖注入。你可以使用相关类，方法或字段声明的注解，将 bean 配置移动到组件类本身。在 XML 注入之前进行注解注入，因此后者的配置将通过两种方式的属性连线被前者重写。注解连线在默认情况下在 Spring 容器中不打开。因此，在可以使用基于注解的连线之前，我们将需要在我们的 Spring 配置文件中启用它。他的作用是式地向Spring容器注册A...
Spring基于注解的配置详解
qq_43408971的博客
10-19 239
Spring配置 从Spring2.5开始支持基于注解的配置，使用@Configuration注解标注配置类，通过AnnotationConfigApplicationContext容器类读取注解配置信息。一个简单的例子如下，其中@Bean注解相当于配置文件中的<bean .../>。 基础类代码 public class Student { private Integer sId; private String sName; private String sGrad
Spring中基于注解的配置详解
InterestAndFun的博客
04-20 1275
在现在的框架开发中，大多数用的都是注解开发技术。注解配置要实现的功能和XML实现的功能都是一样的，只是配置的形式不同。 注解的标签可以分为3类：创建对象、注入数据、其他配置。XML配置文件亦是如此。 看一个简单的例子：例子中的3个框就是分成了3类，这三类标签最后都可以用注解来代替。 现在开始详细介绍spring中的标签。 一、Spring中的标签汇总 用于创建对象： @Component、@Controller、@Service、@Repository 用于注入数据： @Value、@Resource、@
基于注解以及配置类使用SpringIoc
最新发布
hnsqls的博客
04-15 1122
使用注解开发使用ioc，并不能完全摒弃xml配置，还需要使用xml配置扫包，注解使用的范围引入外部文件第三方提供的类，还需要在xml配置，如druid，jdbctemplate什么是配置类，就是将配置文件，改成配置类。扫包 component-scan base-package=“xxx”引入外部文件 property-placeholder location=“xxxx”注册第三方提供的类由于xml解析的效率较低，使用一个类实现以上功能，我们在此称这个类为配置类。@Bean。
注解配置
lady88888888的博客
05-06 572
1、概念 注解（Annotation），也叫元数据（Metadata），是Java5的新特性，JDK5引入了Metadata很容易的就能够调用Annotations。注解与类、接口、枚举在同一个层次，并可以应用于包、类型、构造方法、方法、成员变量、参数、本地变量的声明中，用来对这些元素进行说明注释。 注解是以‘@注解名’在代码中存在的。 2、作用 1.生成文档。这是最常见的，也是java 最早提...
springBoot关于MabiPLUS中提示DAO is Null的问题
weixin_51337996的博客
10-09 825
在dao上加入@Component注解解决，按理说加上@Mappe后会自动添加bean管理，但是没有，所以需要手动再加上这个注解。当你加上后发现还是不行，我试了很多种方法都不行。最否发现是service和dao都交个Spring进行管理后，我在测试类中不能直接进行new产生实体，必须通过@Autiwired从Spring中拿出Bean进行操作才行。教训：交个Spring管理的类还是通过Spring方式获取。
Spring系列二：基于XML配置bean 中
你好, 我在学java的博客
08-07 2068
Spring系列二：基于XML配置bean 中
Spring基于注解的IoC配置
Demon的博客
09-20 2692
基于注解的IoC配置，与在xml中配置目的是一样的，都是降低代码之间的耦合度的，只是配置的形式不一样。 使用注解的步骤：     1、添加context的名称控件和约束     2、开启注解扫描：由spring扫描指定的包及其子包下的所有类，如果类上使用了@Component注解，就将该类装配到容器中     3、在类上使用@Component注解 使用注解之前一定要先开启注解扫描 &lt...
Spring 2.5 学习笔记：IOC, AOP, 注解配置详解
这篇学习笔记主要涵盖了Spring框架2.5版本的相关知识，包括Spring的核心特性、集成SSH框架、IoC（控制反转，Inversion of Control）和DI（依赖注入，Dependency Injection）、注解驱动的配置以及AOP（面向切面编程，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值