2019.6.18 spring的xml和注解

最新推荐文章于 2024-08-19 16:01:20 发布
最新推荐文章于 2024-08-19 16:01:20 发布
阅读量177 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunxing1002/article/details/92764287
版权

spring概要

bean对象的控制反转（IOC）和属性的依赖注入（DI）

spring中对于对象（bean）的三种配置：
（1）常见bean的无参构造的配置

<bean id ="user" class = "sprign.vo.User">
</bean>

（2）工厂类普通方法中创建的bean的配置

public class Bean3Factory {

	public Bean3 getBean3(){
		return new Bean3();
	}
}

<bean id="bean3Factory" class="cn.itcast.spring.demo3.Bean3Factory"></bean>

//注意创建上面bean3的实例的话，id标识要以下面bean3为准奥，上面那个id只是负责定位上面那个类，下面才是入口
//通过下面id确定工厂类的id名为bean3Factory，即定位到cn.itcast.spring.demo3.Bean3Factory类，并且定位
//到工厂中factory-method方法。最终就完成bean3对象的定位输出。
<bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3"></bean>

（3）工厂类静态方法中创建bean的xml的配置

public class Bean2Factory {

	public static Bean2 getBean2(){
		return new Bean2();
	}
}

<!-- 方式二：静态工厂实例化 Bean -->
											 //被spring管理的类是工厂类，但该类方法下创建实例，所以要声明出方法
<bean id="bean2" class="cn.itcast.spring.demo3.Bean2Factory"  
factory-method="getBean2"/>

spring中对于对象（bean）内属性注入的四种情况：
（1）属性通过构造方式的注入，这情况下属性的标识符是 constructor-arg

	<bean id="car" class="cn.itcast.spring.demo4.Car">
		<constructor-arg name="name" value="保时捷"/>
		<constructor-arg name="price" value="1000000"/>
	</bean>

（2）属性通过set方式的注入，这情况下属性的标识符是 property

<bean id="user" class="spring.ov.User">
		 <property name="str" value="abc"></property>
		 <property name="sex" value="男"></property>
		
</bean>

（3）引用类型的属性的注入

//id 是该bean唯一身份标识奥！
<bean id="user1" class="spring.ov.User">
	<property name="age" value="22"></property>
	<property name="sex" value="女"></property>
</bean>

//person类中属性是引用类型，这时在标签property中设置引用参数和普通参数就不同了。
//普通参数是name=属性名称  value=该属性赋的值。
//引用参数是name = 属性名称  ref = 该引用类型对应的bean的id，告知spring去找到该类型的bean，才能帮创建对象奥！
<bean id = "person" class="spring.ov.person">
	<property name="name" value="person_user"></property>
	<property name="user" ref="user1"></property>
</bean>

（4）复杂类型的属性注入：集合等

<!-- Spring 的复杂类型的注入===================== -->
<bean id="collectionBean" class="cn.itcast.spring.demo5.CollectionBean">
   <!-- 数组类型的属性注入 -->
	<property name="arrs">
		<list>
			<value>会希</value>
			<value>冠希</value>
			<value>天一</value>
		</list>
	</property>
  <!-- List 集合的属性注入-->
	<property name="list">
		<list>
			<value>芙蓉</value>
			<value>如花</value>
			<value>凤姐</value>
		</list>
	</property>
  <!--  Map 集合的属性注入 -->
	<property name="map">
		<map>
			<entry key="aaa" value="111"/>
			<entry key="bbb" value="222"/>
			<entry key="ccc" value="333"/>
		</map>
	</property>
  <!-- Properties 类型的注入 -->
	<property name="properties">
		<props>
			<prop key="username">root</prop>
			<prop key="password">123</prop>
		</props>
	</property>
</bean>

控制反转（IOC）注解方式

注解的好处是免了在xml文件中手动注册bean，由spring框架自动向spring容器中注册bean。如@component及其下一些@service、@controller、spring容器中注入bean到变量中
上面是ioc的xml的配置，下面对于其注解的方式
（1）首先引入jar包，在原ioc六个包基础上多了个aop-jar包,因为注解就在里面。
（2）在类路径下创建applicationcontext.xml核心配置文件。（配置文件后，要引入约束，这样有提示）注解要引入context约束。
（3）下面准备类数据，这些都和xml配置文件一样，只是在核心配置文件中不用配置《bean id = “xx” class=“xxx”》了，首先配置注解扫描，用于告诉spring哪些包下哪些类是使用了注解，要你去扫描解析，而不是配置文件的解析（注解的方式其本质上相当于手动在配置文件中设置的作用是一样的。所以注解扫描就可以了，不用在配置文件中去查找bean或者property的配置了）。 就类似于开启了注解模式；如：

<?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: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"> 

！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
//告知框架，在哪个包下的类都用注解解析。开启组件扫描模式。
<context:component-scan base-package="com.sun.annotaion"></context:component-scan>


</beans>

（4）下面就在类上通过注解将类交给spring就ok了（@Component(value=“mycar”) //相当于<bean id=“mycar” class=“被注解的类型”）。注解本质也是将标识的目标装配到spring的核心配置文件中。类似于手动配置bean或者property一样。

@Component(value="mycar") //相当于<bean id="mycar" class="就是下面这个类">
public class mycar implements car {

	
	public void start() {
		System.out.println("我的车启动了1。。。");
		
	}
	public void run() {
		System.out.println("我的车上路了1。。。");
		
	}

	public void stop() {
		System.out.println("我的车熄火了1。。。");

	}

}

（5）上面就完成了控制反转，然后测试一下

public class car_test {

@Test
public void demo2() {
	ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext.xml");
	car car = (car)context.getBean("mycar");
	car.stop();
}
}

结果：
我的车熄火了1。。。

IOC的注解形式和详解

主要是 控制反转类 的 注解 和 属性 的注解
上面发现注解方式免了配置文件中各种设置了，方便了实际开发。但如果改动，还要改源代码，这是弊端。

  • 上面是对象的注解，那属性注入如何注解
  • 基本属性注入的注解——就是在属性上通过@value（“属性值”）就ok了，可以没有set方法奥！有set方法注解就写在方法上，没有就直接写在属性上
@component（类的注解）

作用：就是修饰类的，将该类控制反转给spring（交给spring管理了）。
@component后期分三个：@controller、@service、@repository。由于后期将针对不同层上的属性进行不同注解

属性注解
  1. 普通属性注解：就是@value(“值内容”)就ok了
  2. 引用类型注解： 可以通过@autowired（自动根据类型来依赖注入其内容的值）；区别于以前在配置文件中按照名称name来注入。但是类型注入的话，有时候同一个接口类型的话，就不确定具体哪一个实现类的注入，所以常用@qualifier来明确具体类的id的方式来注入。
  3. 上面两个才实现了按名称的方式来注入的注解方式，有点不太方便，所以又出现一个便捷的@resource注解。实际开发中常用@resource（name=“”）按照名称来注入的注解方式。
    类似于< property name=“属性名” ref=“引用类的id名” > 属性注入这边，属性name开头可以不分大小写。
    （< property name=“age” value=“22”>< /property > name内容是类中属性名，开头不分大小写）
    案例:
@Component(value="sun_car")
public class sun_car implements car {

	@Override
	public void run() {
		System.out.println("第二辆车运行");
	}
	@Override
	public void start() {
		System.out.println("第二辆车开始");
	}
	@Override
	public void stop() {
		System.out.println("第二辆车停止");
	}
}
========================================
@Component(value="mycar") //相当于<bean id="mycar" class="就是下面这个类">
public class mycar implements car {
	@Value("sunxiang")
	private String name;
	
	@Resource(name="sun_car")
	private car car;	
	public void start() {
		System.out.println("2....."+car.getClass());
		car.start();
		System.out.println(name+"我的车启动了1。。。");		
	}
	public void run() {
		System.out.println(name+"我的车上路了1。。。");
	}

	public void stop() {
		System.out.println(name+"我的车熄火了1。。。");
	}
}
=============================================
public class car_test {
@Test
public void demo2() {
	ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext.xml");
	car car = (car)context.getBean("mycar");
	System.out.println("1......"+car.getClass());
	car.start();
}
}
--------------------
结果：
1......class com.sun.annotaion.mycar
2.....class com.sun.annotaion.sun_car
第二辆车开始
sunxiang我的车启动了1。。。
  1. bean生命周期的注解（作用于方法上的注解）——初始化注解：@PostConstruct（在作为初始化的方法上注解标识就ok了，没有其他内容奥!）。销毁注解：@PreDestroy（在某个作为销毁方法上面注解）
  2. bean的作用范围的注解（作用于类上的注解）：@Scope（“singleton/prototype”）
@Test
public void demo2() {
	ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext.xml");
	car car1 = (car)context.getBean("mycar");
	System.out.println(car1);
	
	car car2 = (car)context.getBean("mycar");
	System.out.println(car2);
	}
	----------------------------------
	结果：       由于工厂类默认是单例模式创建bean
	com.sun.annotaion.mycar@1f1c7bf6
	com.sun.annotaion.mycar@1f1c7bf6
IOC的xml和注解的比较
应用场景不同

（1）xml：可以应用于任何场景、且结构清晰，维护方便，直接可以通过xml配置文件可以了解类的整个结构（清晰类中用到哪些属性了，一目了然）。
（2）注解：如果以些类不是自己写的，直接打包成源码的那些，无法进入源码进行注解设置。好处是：开发方便。
（3）xml和注解结合使用：xml管理bean（整个结构中bean很清晰），注解注入属性（省去set方法，类中很清晰。）

<!-- 这个开启扫描的方式，是对于类上注解的应用奥！ -->
<context:component-scan base-package="com.sun.annotaion"></context:component-scan>

<!-- 这个是没有用扫描的方式，这个只用于属性的注解的应用 。
就是类的关联由配置文件，属性通过注解形式，就用下面注解声明的-->
<context:annotation-config></context:annotation-config>

AOP基于aspectj注解方式

一.常见AOP的xml的方式
//下面的配置就是完成spring自动动态代理方式，由spring来完成方法的增强。
//注意虽然spring自动完成代理了，但不能忘记底层动态代理实现的原理奥！！！！！！！只对待增强的方法增强，其他原样输出

 <!-- 这个是目标对象的bean配置  -->
<bean id="mycar" class="spring.ov.mycar"></bean>  
 <!-- 这个是通知对象 的bean配置 -->
  <bean id="enhance" class="spring.ov.enhance"></bean>
  
 <!-- 下面才真正开始aop的配置 -->
 <aop:config >
 	<aop:pointcut expression="execution(* spring.ov.mycar.run(..))" id="pointcutid"/>
 	<aop:aspect ref="enhance" > 
 		<aop:before method="enhan" pointcut-ref="pointcutid"/>  
 								！！！！//前置通知。特点：可以在通知方法内获得切入点信息
 								！！！！！！//特别注意环绕通知，要将待增强方法传入环绕通知内中。
 	</aop:aspect>
 </aop:config>
二 AOP注解的前期准备

（1）同样引入jar包
在这里插入图片描述
（2）编写好目标类 和 切面类（通知类，里面是增强的方法）

//目标类
public class mycar  {
	public void start() {
		System.out.println("我的车启动了2。。。");	
	}
	public void run() {
		System.out.println("我的车上路了2。。。");		
	}
	public void stop() {
		System.out.println("我的车熄火了2。。。");
	}
}
====================================
//切面类（我习惯认为是通知类（增强方法的封装类））这个类很重要！！！！！！！
public class enhance {
public void enhan() {	
	System.out.println("加速度2。。。。");
}
}

（3）注意上面的类上没有注解，说明这边bean的管理没有使用注解管理方式

//这部分仅仅是试验AOP注解，所以IOC的注解没有使用。还是通过配置文件管理bean对象
<bean id ="mycar" class="com.sun.annotaion2.mycar"></bean>
<bean id = "enhance" class="com.sun.annotaion2.enhance"></bean>

（4）下面开始通过AOP注解来对目标类进行增强
同样和IOC注解那样，要在配置文件中（开启注解模式认证）；ioc是开启IOC组件注解扫描，AOP这边要开启：


<!-- 在配置文件中开启AOP的注解模式 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

（5）开启了通过注解的方式来实现aop过程了，那么就可以直接通过注解来完成方法的增强了，不用配置文件中 <aop:config > </aop:config>内进行动态代理的各种配置了。
注意：！！！ 前面分析过AOP面向切面编程（方法增强）中：两个关键点必须要明确

  • 哪个待增强类的哪个方法
  • 通知，就是增强的内容（方法）

这两个关键点都在切面类上体现

（6）注解符号：
@Aspect
@Before（value=“execution(表达式来表示哪个类的哪个方法)”）

（7）AOP注解入门测试：在切面上注解AOP的两个关键点：哪个类哪个方法要增强、通知（增强的内容/方法）

//通知类
@Aspect
public class enhance {
	
@Before(value="execution(* com.sun.annotaion2.mycar.run())")
public void enhan() {
	System.out.println("加速度2。。。。");
}
}

（8）AOP注解方式，只在切面类上注解设置，目标类上没有改变。即：

//目标类上和xml一样没有任何改动
public class mycar  {
	public void start() {
		System.out.println("我的车启动了2。。。");	
	}
	public void run() {
		System.out.println("我的车上路了2。。。");		
	}
	public void stop() {
		System.out.println("我的车熄火了2。。。");
	}
}

（9）注解方式的AOP实现的增强结果显示：最终完成对目标类mycar的run()方法的增强。源代码没任何改变。

public class car_test2 {
	@Test
	public void demo2() {	
	ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext2.xml");
	mycar car1 = (mycar)context.getBean("mycar");		
		car1.run();
	}
}
-------------------------------------
测试结果：
加速度2。。。。
我的车上路了2。。。

（10）测试类中可以结合spring的junit测试方式来表示：要引入spring-junit结合的jar包；对比上面测试代码，省略了工厂对象的创建。而且mycar的bean对象一属性注入的方式产生，不用写工厂对象的getbean获取，节省代码。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationcontext2.xml")
public class car_test2 {
	@Resource(name="mycar")
	private mycar car1;
@Test
public void demo2() {	
	car1.run();
}
}
-------------------------------------
测试结果：
加速度2。。。。
我的车上路了2。。。

对比下AOP的xml方式和注解方式：

  • 首先AOP关键点：切入点和通知。
  • 本质：要在切入点上添加通知；通俗说就是在哪个类的哪个方法上通过AOP方式进行增强。

中心思想：就是想在指定类的指定方法上进行增强。
（1）原始思想：创建类的时候，在方法中直接调用增强的方法。
（2）继承思想：将增强的方法封装，然后继承这个类，在方法中调用增强的方法，避免原始思想在所有要增强的类中都创建增强方法，然后调用增强方法。
（3）动态代理思想：只写一个动态代理类，然后传入要增强的类，并针对这个类中指定方法进行增强，任何增强的改变只在代理类中完成，不用像继承那样，增强方法的添加和删除的话，要所有类上都去掉继承。
（4）动态代理之后演进成AOP了（底层实现），接着又由Aspectj规范封装了，最后spring又引入Aspectj的aop，所有核心就是类似于动态代理奥！！！！所有出现两个关键点：哪个类的哪个方法要增强，增强的方法
（5）对于两个关键点：Spring的AOP的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: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.xsd
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd"> 


<bean id ="mycar" class="com.sun.annotaion2.mycar"></bean>
<bean id = "enhance" class="com.sun.annotaion2.enhance"></bean>

<aop:config>
//切入点，就是明确哪个类的哪个方法
<aop:pointcut expression="execution(* com.sun.annotaion2.mycar.run(..))" id="run1"/>  

<aop:aspect ref="enhance">
//明确增强的内容（方法）
<aop:before method="enhan" pointcut-ref="run1"/>
</aop:aspect>

</aop:config>
=========================================
//切面类就是基本的增强方法的封装
public class enhance {	
	public void enhan() {		
		System.out.println("加速度2。。。。");
	}
}

（6）对于Spring的AOP的注解体现： 对比配置文件形式，就是将aop:config</aop:config>内属性设置直接在切面类上注解设置（体现）了。还是设置两个关键点：具体哪个类的哪个方法，还有增强的内容（方法）

<!-- 在配置文件中开启AOP的注解模式 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

<bean id ="mycar" class="com.sun.annotaion2.mycar"></bean>
<bean id = "enhance" class="com.sun.annotaion2.enhance"></bean>

========================================
//注解主要是在切面类中注解设置的。
@Aspect
public class enhance {	
@Before(value="execution(* com.sun.annotaion2.mycar.run())")
public void enhan() {	
	System.out.println("加速度2。。。。");
}
}

（7）上面5和6，AOP的配置的测试结果都一样

package com.sun.annotaion2;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationcontext2.xml")
public class car_test2 {
	@Resource(name="mycar")
	private mycar car1;
@Test
public void demo2() {
	
	car1.run();
}
}
==================================
测试结果：
加速度2。。。。
我的车上路了2。。。

（8）同样后置通知配置的话，注解的话直接在通知方法上注解就可以了，不用到配置文件下那样配置。直接通知方法上@AfterReturning(value=“execution(* com.sun.annotaion2.mycar.run())”)就ok了。
环绕通知的注解和xml比较：

<aop:config>
<aop:pointcut expression="execution(* com.sun.annotaion2.mycar.run(..))" id="run1"/>
<aop:pointcut expression="execution(* com.sun.annotaion2.mycar.stop(..))" id="stop"/>
<aop:aspect ref="enhance">
<aop:before method="enhan" pointcut-ref="run1"/>
<aop:around method="around" pointcut-ref="stop"/>
</aop:aspect>
</aop:config>
========================================
@Aspect
public class enhance {
	
private Object proceed;
@Before(value="execution(* com.sun.annotaion2.mycar.run())")
public void enhan() {
	
	System.out.println("加速度2。。。。");
}
@AfterReturning(value="execution(* com.sun.annotaion2.mycar.run())")
public void after() {
	
	System.out.println("太快了，注意减速2。。。。");
}
@Around(value="execution(* com.sun.annotaion2.mycar.stop())")
//环绕通知相比于前置和后置，要特殊点，注解只在方法上注解，其他环绕方法内容和配置文件方式一样，没有改变
public Object around(ProceedingJoinPoint joinpoint) throws Throwable {
	System.out.println("环绕前。。。。。");
	proceed = joinpoint.proceed();
	System.out.println("环绕后。。。。。");
	return proceed;
}


/*
//环绕通知的注解要注意一下，原本没注解的方式也和其他前置后置不同
@Around("MyAspectAnno.pointcut3()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
System.out.println("环绕前通知==========");
Object obj = joinPoint.proceed();
System.out.println("环绕后通知==========");
return obj;
}
*/


}

小结

IOC注解中特别关注：类的注解（bean对象的管理） 和 类中属性的注解（属性注入）
AOP注解中特别关注：切入点（哪个类的哪个方法）的注解 和 通知的注解，都是在切面类上注解这两个关键信息的。特别是哪个类哪个方法别忘了，这表示通知要切入的目的位置奥，如前置注解：就是表示这个通知要切入的位置mycar类下的run（）方法、之前切入

@Before(value="execution(* com.sun.annotaion2.mycar.run())")
public void enhan() {
	System.out.println("加速度2。。。。");
}
子系shine
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring security原理和机制 | Spring Boot 35
学Java，找哪吒
06-25 5万+
一、SpringSecurity 框架简介 Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。 正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring
14. Spring Boot 2.x 最佳实践之 Spring Security 集成
极客星云-CSDN博客
11-30 1402
Spring Boot 2.x 最佳实践之 Spring Security 集成
java中VO的使用mybatis注解,Mybatis XML与注释
weixin_34194829的博客
02-25 363
I have read the book and documentation about Mybatis, both XML and Annotation does what I want, but from myBatis official website, they claim XML is a better way of doing Mappers, because Java annotat...
Easymall项目分布式拆分整合(五）
LiuY521的博客
06-10 480
Easymall项目分布式拆分整合(五） 目录 Easymall项目分布式拆分整合(五） 一.搭建后台商品系统 1.1搭建步骤 1.maven quickstart(springboot) 2.继承parent,依赖common 3.product工程还需要访问持久层,redis(common依赖的传递) 4.appl...
2019.6.30 Spring注解 bean后置处理器和属性赋值
aeqjua8065的博客
07-01 302
6.30 BeanPostProcessor是一个接口，用于在bean初始化之前和之后调用。(在bean属性赋值之后) 需要实现其中的2个方法 @Component public class MyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBe...
spring学习6-使用xml方式实现spring基本应用
qq_41632427的博客
08-12 105
spring
SpringBoot使用LogAop和logback-spring.xml配置
anhao的博客
01-06 820
一、在logback.xml中写表达式时需要导入janino依赖 <dependency> <groupId>org.codehaus.janino</groupId> <artifactId>janino</artifactId> <version>3.0.6</version> &l...
Spring Cloud Alibaba 参考文档-2021.0.4.0
wcuu的博客
02-07 3244
Nacos中命名空间的详细介绍，请参考Nacos概念命名空间用于隔离不同租户的配置。不同命名空间中的组和数据 ID 可以相同。命名空间的典型场景是不同环境的配置隔离，例如开发/测试环境和生产环境（配置和服务等）的隔离。如果没有指定命名空间，则使用 Nacos 的“公共”命名空间${spring.cloud.nacos.config.namespace}。此配置必须位于 bootstrap.properties 文件中。
Spring Aop xml配置和注解配置
Big Data
06-20 414
1、创建目标类 /** * @author 作者 Your-Name: * @version 创建时间：2019年5月31日 上午10:35:08 * 类说明 */ package com.sumeng.aop; /** * @author Administrator * */ public class UserInfo { public void add(){...
corespring5certificationindetail.pdf
08-29
此外，还会讨论XML配置和基于注解的配置方式，以及Bean的定义和实例化过程。 2. 面向切面编程（AOP） AOP是Spring框架的重要特性，允许开发者定义“切面”——代码模块，这些模块关注于程序中的某个特定方面，如...
spring-framework-5.1.8.RELEASE.zip
06-28
6. **测试模块**：`spring-test`，支持单元测试和集成测试，方便开发者进行功能验证。 导入这些jar包到项目中，可以通过XML配置或者使用Java配置类来创建和管理Bean。同时，Spring还支持注解驱动的开发，比如@...
Spring框架的前世今生已经源码构建.rar
05-14
- 通过XML配置、注解或Java配置，开发者可以声明组件间的依赖关系，使得代码更易于测试和维护。 3. **面向切面编程（AOP）**： - AOP允许将横切关注点（如日志、事务管理）从核心业务逻辑中分离出来，提高了代码...
SpringBoot+Mybatius图书管理系统 语言：Java 开发工具：IntelliJIDEA-2019.3.zip
02-04
- 映射文件与Mapper接口：Mybatis通过XML映射文件或注解方式定义SQL语句，同时提供Mapper接口与之对应，实现SQL的动态执行。 - 数据源配置：SpringBoot可以自动配置多种数据源，如Druid、HikariCP等，实现数据库...
spring学习记录(四)——bean的作用域、自动注入(XMl和注解)
qq_49474261的博客
08-10 400
spring学习记录
【链表在Java中DeBug】
最新发布
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
08-19 252
时，你实际上是在告诉当前节点 cur：“你的下一个节点应该是这个新创建的节点。，你将 cur 的引用更新为新创建的节点，这样 cur 现在就指向了你刚刚添加到链表末尾的节点。实际上，head 是一个固定的引用，它始终指向链表的第一个节点（即头节点）。当你看到链表似乎“增长”了，这实际上是因为你通过操作 cur（当前节点的引用）在链表的末尾添加了新的节点。所以，当你看到链表“增长”时，你实际上是在通过更新节点之间的链接（即 next 指针）来扩展链表结构。它只是保持了对链表起始节点的引用。
Linux配置Maven环境
Java全栈开发者
08-18 443
官网地址：https://maven.apache.org/download.cgi。获取其对应的下载链接（也可以使用下载到本地后，手动上传到服务器的方式）切到自己想要存放的路径后，使用wget下载。使用pwd查看文件路径，ll查看文件名称。这里以当前最新版本3.9.8为例。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 964
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
【Spring框架】
m0_71941456的博客
08-18 1013
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
Spring3.x MVC注解详解与实例
"这篇文档详细介绍了Spring 3.x MVC框架中的注解使用，特别是与Web应用程序相关的注解，包括实际的示例应用PetClinic和imagedb。它强调了如何配置DispatcherServlet来支持注解处理，以及如何通过定义特定的Bean来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值