学习过程的Spring，自我感觉很是全面，但不算是高精尖。

最新推荐文章于 2022-08-13 20:08:10 发布
最新推荐文章于 2022-08-13 20:08:10 发布
阅读量232 收藏
点赞数
文章标签： Spring IOC DI AOP 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38030815/article/details/94641115
版权

开源企业级轻量级框架Spring

概述

Spring框架提供了一个全面的现代java企业应用程序编程和配置模型——在任何类型的部署平台。
Spring是基础设施的一个关键要素支持在应用程序级别:Spring集中在企业应用程序的“管道”,团队可以专注于应用程序的业务逻辑,没有不必要的关系到特定的部署环境。
Spring框架分为模块。应用程序可以选择他们所需要的模块。核心的模块是核心容器,包括配置模型和依赖注入机制。除此之外,Spring框架提供基础支持不同的应用程序架构,包括消息、事务性数据和持久性和网络。它还包括基于servlet的Spring MVC web框架

  • 特性2019-04-23-09-52-18

  • 框架概览图：Spring框架的各个特性被组织成20个模块。这些模块被分组成Core Container（核心容器）, Data Access/Integration（数据访问/集成）, Web（网络端）, AOP (Aspect Oriented Programming，切面编程), Instrumentation, Messaging（消息）,和Test（测试）， 以下图片显示的就是Spring的各个模块：
    2019-04-23-09-56-08

基于spring4上图谈谈整体架构

链接: Spring整体架构和jar包依赖关系详解.
链接：第一章：spring5.0概述

springIOC和DI

spring的约束

spring官方提供了xml配置文件的规范，也就是配置文件（applicationcontext.xml）的约束文件dtd和schema（后缀xsd）

简单解释

Java应用 — 运行着小到各种受限的小程序，大到n层结构的服务器端企业级应用 — 包含着相互协作的对象，从而创建正确的应用。 因此，程序里的对象彼此之间相互依赖。
尽管Java平台提供的很多功能性的应用程序（这个时候比较散比较杂，比如Jar包啊），但是他缺少将这些基础组件组织成一个整体的方法，最终把这些整合工作交给了架构师或是开发者。你可以使用设计模式，例如工厂，抽象工厂，建造者，装饰和服务定位来将这些不同的类和示例对象组合起来，从而构建一个应用（虽然将某些多的jar或者组件通过各种模式组装，但是毕竟不如成品来的痛快）。 但是，这些模式仅仅只是：一个被给予名字的最佳实践，说明了该模式做什么，怎样应用，解决了什么问题等等。 模式是形式化的，你必须在你的应用中去实现它。
Spring中的控制反转 (IoC)部分解决了这个问题，通过提供一种有效的方式将各个分开的组件组合成一个完全可供使用的应用。 Spring框架用函数化的形式实现了形式化的设计模式，这样你就可以在你的应用中继承它们。很多组织个机构正在使用Spring框架来设计健壮的，便于维护的应用。

pring IoC容器设计原理及高级特性

直接看吧
Spring IoC容器设计原理及高级特性

使用IOC容器进行依赖注入简化操作

XML方式

控制反转简单属性

  • 对象懒加载与单例
Lazy-initcope对象的创建结果
Truesingleton单例对象创建懒加载
Trueprototype 多例对象创建懒加载
Default/falsesingleton单例对象创建立即加载
Default/falseprototype多例对象创建懒加载
注意懒加载并不是传说的单例模式，他只是在容器中之加载一次名ID的对象
  • 工厂生产的属性
模式属性用法
静态工厂factory-method：指定对应工厂方法的名称，class是静态工厂类的全路径将两个属性书写正确并定义ID后，容器会调用静态工厂方法生成对应实例
实力工厂factory-method：指定对应工厂方法的名称，factory-bean：对应工厂的实例实例工厂需要在之前将实例工厂的对象加入容器，并不需要定义class（定义了写谁？）
spring工厂class：声明为工厂路径不同的是采用spring工厂的方式，要求工厂类必须实现类：org.springframework.beans.factory.FactoryBean重写方法：getObject() throws Exception、Class getObjectType()、boolean isSingleton()注意：配置不同属性告诉spring你要什么样的模式实现对象的生产及管理

下面是一些实例代码
简单注入使用

<!-- setter的属性和对象注入 -->
<!-- 注入时利用元素property -->
	<bean id="beanB" class="com.tedu.springDI_01.ClassB">
		<property name="id" value="10086"></property>
		<property name="name">
			<value>kongkongWorld</value>
		</property>
		<property name="date" >
			<bean class="java.util.Date"></bean>
		</property>
		<property name="date01" ref="ddd"></property>
		<property name="ia" ref="beanA"></property>
	</bean>
	<!-- 构造器可以带参注入 -->
	<bean id="beanBC" class="com.tedu.springDI_01.ClassB">
		<constructor-arg index="0" value="10010"></constructor-arg>
		<constructor-arg name="name" >
			<value>张三</value>
		</constructor-arg>
		<constructor-arg index="2" ref="ddd"></constructor-arg>
		<constructor-arg index="3" ref="ddd"></constructor-arg>
		<constructor-arg type="com.tedu.springIOC_01.InterfaceA" ref="beanA"></constructor-arg>
	</bean>
	<!-- autowired  ID和class后直接写入属性autowired=default|no|byName|byType|constructor -->
	<bean id="cc" class="com.tedu.springDI_01.ClassC"></bean>
	<bean id="dd" class="com.tedu.springDI_01.ClassD"></bean>
	<bean id="beanET" class="com.tedu.springDI_01.ClassE" autowire="byType"></bean>
	<bean id="beanEN" class="com.tedu.springDI_01.ClassE" autowire="byName"></bean>

进阶一些，对list，set，map，property进行注入

	<!-- 命名空间注入 相当于在springIOC容器中加载一个set集合对象 -->
	<util:set id="hero_set">
		<value>set_01</value>
		<ref bean="t_1" />
	</util:set>
	<bean id="hero" class="tedu.ioc.com.BeanTest">
		<property name="list">
			<list>
				<value>list_01</value>
				<value>list_02</value>
				<ref bean="t_1" />
			</list>
		</property>
		<property name="set" ref="hero_set"></property>
		<property name="map">
			<map>
			 <!-- 注意在map注入时时entry -->
				<entry key="key_1" value="value_1"></entry>
				<entry key="key_2" value-ref="t_1"></entry>
				<entry key-ref="t_1" value-ref="t_2"></entry>
			</map>
		</property>
		<property name="prop">
			<props><!-- 多了一个props，命名空间注入时不需要此元素 -->
				<prop key="公子">宝剑</prop>
				<prop key="佳人">折扇</prop>
			</props>
		</property>
	</bean>
注解方式（着重掌握）

开启注解扫描
@ComponentScan：若没有设置basePackages=“包名”，则默认扫描当前包下的所有类,替换XML文件的<Context:Component-Scan base-packages=”包名”>
IOC和Di注解汇总

  • 想容器中加载Bean（IOC）（替换了xml里的Bean元素）
名称意义
@Controller修饰在Controller控制器的类上
@Serice修饰在Service业务类上，可以用@Component替换
@Repository修饰在Dao数据库访问类上，可以用@Component替换
@Component修饰在无法归类的类别上，比如xxUtil类
@Bean遇到第三包而且我们还需要Bean的时候怎么办，比如数据源对象，Spring提供Bean注解，注解在方法上将方法返回值作为对象放置在容器中
  • 依赖注入（DI）
名称意义
@Resource由JDK提供的若不指定（name=”xxx”）默认按照名称装配，装配名称采取属性名
@Autowired由spring-Context包提供，默认按照类型装配，若有歧义或者通过有多个实现类的接口实现的时候，采取@Autowired@Qualifier（name=“”）进行精确装配。由于以上两个支持到参数，进行有参构造类的IOC的时候，可将注解放置到构造的参数上完成当前类的依赖注入
@Value括号里直接值（整数也带双引号，会自己转的）
@Inject、@Name用到第三方jar包。不做解释
  • 其他注解比如属性配置之类的----未完待续
名称意义
@Scope(value=“prototype”)单例和多例 修饰在类上
@Lazy//代表懒加载 修饰在类上
@PostConstruct表示Bean初始化操作的自定义方法 修饰在方法上
@PreDestroy表示销毁Bean时的自定义方法 修饰在方法上
@Primary自动装配时当出现多个Bean候选者时，被注解为@Primary的Bean将作为首选者，否则将抛出异常
@propertySource加载配置文件进入SpringIOC容器，属性：name、value、ignoreResourceNotFound（默认false抛异常）、encoding
@import这是在Spring元数据类（相当于一个XML文件）较多时进行添加的操作，比如在一个ApplicationConfig类上。@Import（{ApplicationConfig2.class，ApplicationConfig3.class}）可以替换在Xml中的
@ComponentScan若没有设置basePackages=“包名”，则默认扫描当前包下的所有类替换XML文件的<Context:Component-Scan base-packages=”包名”>
顺道提一嘴

先定义：注意这时候不会初始化，不会初始化，不会初始化

  • Resource：定位，根据开发者的定义的内容进行资源定，注解和Xml都是可以的。
  • BeanDefinition：的载入，这个时候将Resource定位到的信息保存到BeanDefinition中，此时仍旧没有创建对应实例
  • BeanDefinition的注册：将DeanDIFinition的信息注册到SpringIoc容器中，
    初始化和依赖注入：注意这个时候要去检查是否lazy-init=”true”

在这里插入图片描述

SpringAop

AOP的核心代理设计模式

2019-04-24-10-53-23
为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。准确的说，需求对象不能很好的使用或者很好的整合被需求对象，比如对被需求对象做出事务控制的时候，我们不能直接对被需求对象做出直接修改，就需要代理对象做出整合，将需求对象（事务控制）织入被需求对象中。

  • 抽象对象：业务的抽象接口。
  • 真实对象：被代理对象，需要对其业务进行补充或者访问控制的对象
  • 代理对象：对真实对象的问题提供了解决方案，方便使用者即使有效的使用真实对象。
    静态代理：代理对象是由程序猿创建的，而且一个Proxy一般就只能代理一类目标对象（实现共同Subject接口），相当于代理类和被代理类关系提前要确定。
    动态代理：在实现阶段不用关心代理类的具体实现，而是在运行时才生成代理对象（JAVA中是通过反射实现，具体见下文）平台或者三方库有提供。动态代理的扩展性更高，所以一般一些开源框架都会使用。

动态代理之JDK动态代理

JDK动态代理是JDK的Java.lang.reflect包下提供的代理技术，不需要提供第三方JAR包，到需要被代理对象具有抽象接口。

角色分析：
  • 被代理接口：被代理业务的抽象性接口，为具体业务提供抽象声明（面向接口编程，另外没有接口也使用不了JDk的代理技术啊）
  • 被代理实现对象：提供业务的具体实现，也是代理对象的真实需要代理的业务逻辑对象
  • 代理对象：对需要代理的业务进行扩展和控制的对象。也是我们正在制造的对象
实现逻辑：
  • 代理对象实现新业务逻辑的地方：一个实现InvocationHandler接口的实现类，重写其invoke方法。
public Obejct invoke(Object proxy,Method method,Object[] args){ } 
//Object 目标方法（被代理的方法）的返回值=method.invoke(老业务对象,目标方法的参数);
//proxy：内部生成的代理类的对象，他将调用这个方法
//method：目标方法的的Method对象，调用>invoke方法。将使用逻辑。
//args：目标方法的参数数组，
  • 产生代理对象的方法：Proxy的静态方法newProxyInstance()
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces, InvocationHandler h)throws IllegalArgumentException
//loader是真实对象的类加载器
//interface是被代理接口
//h是继承InvocationHandler的实现类,此参数将新业务或者说新的要求同被代理业务耦合
  • 用户使用真实对象：通过产生代理对象的逻辑直接拿到代理对象，并赋予被代理接口引用，最后直接调用就ok啦！！！！
JDK源码原理实现分析

在这里面无非解释了一个问题，JDK动态代理实现的逻辑是，根据那你的在proxy. newProxyInstance里面填入的父接口信息创建一个子实现（包含equals、toString、hashcode和需对应父接口要代理的逻辑的方法实现），所以JDK生成的代理对象（还会继承Proxy类）和被代理对象（真实对象）是兄弟关系。

cglib动态代理

导入第三方包

<dependency>
    <groupld>cglib</groupld>
    <artifactld>cglib</artifactld>
    <version>3.2.10</version>
</dependency>
代理对象实现新业务逻辑的地方

一个实现MethodInterceptor接口的实现类，重写其intercept方法。

public Object intercept(Object proxy,Method method,Object[] args,MethodProxy methodProxy){}
//Object 目标方法（被代理的方法）的返回值=method.invoke(老业务对象,目标方法的参数);
//proxy：cglib生成的代理对象  
//method：被代理对象业务方法的对象。
//args：目标方法的参数数组，
//methodProxy：代理方法，使用methodProxy.invoke方法调用原来的业务
产生代理对象的方法：

通过增强类Enhancer产生代理对象

Enhancer enhancer = new Enhancer();
enhancer.setSuperClass(Class cla);//cla是被代理类的class对象
enhancer.setCallback(实现MethodInterceptor接口的对象);
enhancer.create();//返回一个代理对象
//第二步是将代理逻辑绑定到哪一个业务上或者说类上，cglib内部也是通过他来生成其子类，就是此业务的代理类。
//第三部是将代理对象将我们规定的新业务或者说我们希望代理后的业务绑定。
用户使用真实对象：

通过产生代理对象的逻辑直接拿到代理对象，并赋予被代理类的class对象，最后直接调用就ok啦！！！！

cglib源码原理实现分析：

cglib动态代理实现的逻辑是，根据那你的在enhancer.setSuperClass里面填入的类信息创建一个子实现，通过拦截器的等模式实现动态代理，所以cglib代理对象和被代理对象（真实对象）是父子关系。
需要注意的是：Cglib动态代理执行代理方法效率之所以比JDK的高是因为Cglib采用了FastClass机制，它的原理简单来说就是：为代理类和被代理类各生成一个Class，这个Class会为代理类或被代理类的方法分配一个index(int类型)。这个index当做一个入参，FastClass就可以直接定位要调用的方法直接进行调用，这样省去了反射调用，所以调用效率比JDK动态代理通过反射调用高。
若调用method.invoke方法会造成方法循环调用的死循环，
另外cglib不能代理带final的方法的

两种的区别

  • JDK动态代理是实现了被代理对象的接口，Cglib是继承了被代理对象。
  • JDK和Cglib都是在运行期生成字节码，JDK是直接写Class字节码，Cglib使用ASM框架写Class字节码，Cglib代理实现更复杂，生成代理类比JDK效率低。
  • JDK调用代理方法，是通过反射机制调用，Cglib是通过FastClass机制直接调用方法，Cglib执行效率更高。

说完动态代理现在说一下AOP

核心概念

Aop的底层核心是动态代理技术，通过这种模式来掌管各个对象的操作的切面环境，包括事务管理、日志打印等。让我们在可以调用愿业务的同时可以织入我们后期更新维护的逻辑，比如为了安全性而加入事务管理逻辑，甚至新情况发生需求不符合逻辑可以屏蔽原有业务。
并且，在有些流程中，比如数据库事务管理，aop会提供默认的实现逻辑，也会提供一些默认的配置比如spring的声明式事务，大大减少了开发量，提高大吗的可读性和可维护性，让程序员可以更加集中开发在业务上。

基本定义
名称定义
切面（aspect）切面就是我们要织入的业务逻辑岑在的环境，简单可以理解城北插入的新业务方法存在的类，在这里可以定义通知（要织入的逻辑）
切点（Pointcut）这是SpringAop启动拦截的点，一个切点可以有许多的连接点，当需要某个方法前织入一段通知，我们就需要使用切点信息来确定在那些连接点上添加通知。within可具体控制到类，execution具体控制到方法。
连接点（joinpoint）是程序执行的某个特定的位置，例如：类初始化前后，这就是两个位置。
通知（advice）通知是切面开启后，切面的方法业务，他根据逻辑在真实业务调用之某个连接点开启通知。before、after、afterRunning、afterThrowing、around。
目标对象（target）我们需要对他进行业务通知的业务对象
引介引介是一种特殊的通知。 它为类添加一些属性和方法。这样，即使一个业务类原本没有实现某个接口，通过AOP的引介功能，我们可以动态的为该业务类添加接口的实现逻辑，让业务类成为这个接口的实现类。
使用XMl方式运行AOP

定义切面，规定切点，声明通知（剩下的还用我说嘛）
在xml中可以配置的元素

AOP配置元素|用途|备注
aop：advisor|定义Aop的通知器|方式较老目前很少用
aop:aspect|定义一个切面|
aop：before|前置通知	|
aop：after|后置通知	|
aop：around	|环绕通知|	
aop：after-returning|返回通知|	
aop：after-throwing	|异常通知|
aop：config|顶层的aop配置元素|aop的配置是以它开始
aop：declare-parents|给通知引入新的额外的接口增强功能|
aop：pointcut|定义切点|通过expression属性配置要拦截的方法或者说要代理的业务。

具体代码实例
xml配置

	    <!-- 业务对象 -->
	    <bean id="userService" class="testspringAOP.service.UserServiceImpl"></bean>
		<!-- 代理对象 -->
		<bean id="taransaction" class="testspringAOP.transaction.Transaction"></bean>
		<!-- spring-aop的配置逻辑 -->
		<aop:config proxy-target-class="false">
			<!-- 声明切面   谁去代理,要去做横切业务的类是新务类 -->
			<aop:aspect id="txAspect" ref="taransaction">
				<!-- 声明切点  代理的结果,需要代理的具体业务 -->
				<aop:pointcut expression="execution(* testspringAOP.service..*.*(..))" id="txPointCut"/>
			<!-- 通知,对业务做的改进更新的业务逻辑,分为五种 -->
				<!-- 前置 -->
				<aop:before method="before" pointcut-ref="txPointCut"/>
				<!-- 后置 -->
				<aop:after method="after" pointcut-ref="txPointCut"/>
				<!-- 最终 -->
				<aop:after-returning method="after_returning" pointcut-ref="txPointCut" returning="returnVa"/>
				<!-- 异常 -->
				<aop:after-throwing method="after_throwing" pointcut-ref="txPointCut" throwing="ex"/>
				<!-- 环绕 -->
				<aop:around method="around" pointcut-ref="txPointCut"/>
			</aop:aspect>
		</aop:config>

切面java书写

	public void before(JoinPoint jp) {
		System.out.println("before：--------------------------->"+"开启事务/前置通知,老业务方法还没有执行/"+
				"目标对象的类"+ jp.getTarget().getClass()+
				"目标方法的名称"+ jp.getSignature().getName()+
				"目标方法的参数"+ jp.getArgs()[0].getClass());
	}
	public void after(JoinPoint jp) {
		System.out.println("after：--------------------------->"+"提交事务/后置通知,老业务方法执行完毕/");
	}
	public void after_returning(JoinPoint jp,Object returnVa) {
		System.out.println("after_returning：--------------------------->"+"最终通知,老业务方法执行了,不一定执行完毕"+"目标方法的返回值"+ returnVa);
	}
	public void after_throwing(JoinPoint jp,Throwable ex) {
		System.out.println("after_throwing：--------------------------->"+"回滚事务/异常通知,老业务方法执行了,但是执行某语句,报异常："+"目标方法的异常"+ex);
	}
	public Object around(ProceedingJoinPoint pjp) {
		Object returnValue = null;
		System.out.println("around：--------------------------->");
		try {
			System.out.println("around------------------前置逻辑");
			returnValue = pjp.proceed();
			System.out.println("around-----------------后置逻辑");
		} catch (Throwable e) {
			System.out.println("around-----------------异常逻辑");
		}finally {
			System.out.println("around------------------最终逻辑");
		}
		return returnValue;
	}

注意：

  • 在最终和异常通知内，一般情况下，是需要对应参数的。所以在xml一定要配置对应的那两个属性，并且属性值要和代码里的形参名一致
  • 多个参数时JoinPoint一定要放在一个，具体应给和内部的原理有关。
  • 还有其他使用方式，不再一一介绍
    其他使用时候的逻辑不做详细概述了，测试时启动spring容器后，获取业务对象直接调用原有逻辑就好。
使用注解的方式

开启注解
@EnableAspectJAutoProxy，放在类上或者在XML中<aop:aspect-autoproxy/>就可以启动AspectJ框架的自动代理，这时候Spring才会自动加载代理对象进而使用Aop
使用注解如下：

注解名称
@Aspect注册切面，应用于类
@Before前置通知
@AfterReturning最终通知
@AfterThrowing异常通知，企业中的异常对象最大也就Exception，有时也需要自定义异常
@After后置通知
@Around环绕通知
@Pointcut声明切点

切点的指示器
within和execution

  • execution控制粒度细，控制到方法上（修饰符 返回值 报名.类名 方法（参数））
  • wethin 控制粒度粗，控制到类
    除此之外还有arg（）、target（）
    下面是execution的一些举例
  • the execution of any public method:
    execution(public * *(..))
  • the execution of any method with a name beginning with “set”:
    execution(* set*(..))
  • the execution of any method defined by the AccountService interface:
    execution(* com.xyz.service.AccountService.*(..))
  • the execution of any method defined in the service package:
    execution(* com.xyz.service.*.*(..))
    具体代码实例
@Aspect
public class Transaction_ann {
	@Pointcut("execution(* testspringAOP.service..*.*(..))")
	public void myPoint() {
	}
	@Before("execution(* testspringAOP.service..*.*(..))")
	public void before(JoinPoint jp) {
		System.out.println("before：--------------------------->"+"开启事务/前置通知,老业务方法还没有执行/"+
				"目标对象的类"+ jp.getTarget().getClass()+
				"目标方法的名称"+ jp.getSignature().getName()+
				"目标方法的参数"+ jp.getArgs()[0].getClass());
	}
	@After("myPoint()")
	public void after(JoinPoint jp) {
		System.out.println("after：--------------------------->"+"提交事务/后置通知,老业务方法执行完毕/");
	}
	@AfterReturning( value = "myPoint()",returning = "returnVa")
	public void after_returning(JoinPoint jp,Object returnVa) {
		System.out.println("after_returning：--------------------------->"+"最终通知,老业务方法执行了,不一定执行完毕"+"目标方法的返回值"+ returnVa);
	}
	@AfterThrowing(value = "myPoint()",throwing = "ex")
	public void after_throwing(JoinPoint jp,Throwable ex) {
		System.out.println("after_throwing：--------------------------->"+"回滚事务/异常通知,老业务方法执行了,但是执行某语句,报异常："+"目标方法的异常"+ex);
	}
	@Around(value = "myPoint()")
	public Object around(ProceedingJoinPoint pjp) {
		Object returnValue = null;
		System.out.println("around：--------------------------->");
		try {
			System.out.println("around------------------前置逻辑");
			returnValue = pjp.proceed();
			System.out.println("around-----------------后置逻辑");
		} catch (Throwable e) {
			System.out.println("around-----------------异常逻辑");
		}finally {
			System.out.println("around------------------最终逻辑");
		}
		return returnValue;
	}
}

springJDBC

springJDBC模板类的使用

导入第三方包

mysql驱动包

    <dependency>
	  <groupId>mysql</groupId>
	  <artifactId>mysql-connector-java</artifactId>
	  <version>版本</version>
	</dependency>

spring-jdbc

    <dependency>
	  <groupId>org.springframework</groupId>
	  <artifactId>spring-jdbc</artifactId>
	  <version>版本</version>
	</dependency>

spring-tx

    <dependency>
	  <groupId>org.springframework</groupId>
	  <artifactId>spring-tx</artifactId>
	  <version>版本</version>
	</dependency>

第三方数据源（DBCP，C3P0,druid等）

    <dependency>
	  <groupId>com.alibaba</groupId>
	  <artifactId>druid</artifactId>
	  <version>版本</version>
	</dependency>
将数据源、模板类等交给spring管里

在spring的元数据里配置（将数据库的数据写在了配置文件中）如下

<!-- 将配置文件加载到容器 -->
<context:property-placeholder location="classpath:conf/mysql.properties"/> 	
<!-- spring jdbc Template -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.jdbcTemplate">
    <property name="dataSource" ref="alibabaDataSource"></property>
</bean>
<!-- 数据库连接池 commons-dbcp ,c3p0,proxool,阿里巴巴druid -->
<bean id="alibabaDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <!-- 数据库连接的4项 -->
	<property name="driverClassName">
		<value>${jdbc_driverClass}</value>
	</property>
	<property name="url">
		<value>${jdbc_url}</value>
	</property>
	<property name="username">
		<value>${jdbc_userName}</value>
	</property>
	<property name="password">
		<value>${jdbc_userPassword}</value>
	</property>
</bean>
使用时将容器加载后，获取模版类实例，提供对应的sql然后直接进行对应的增删查

注意在另个方式中可以使用springJDBC内嵌的数据源，然后在dao类继承org.springframework.jdbc.core.support.JdbcDaoSupport类，在使用时通过super.getJdbcTemplate()来获取对应的数据操作的模板类对象。进而简单操作数据库。

JdbcTemplate模版类的具体方法调用展示
    // jdbc模板
    @Resource(name="jdbcTemplate")
    private  JdbcTemplate jdbcTemplate;
    public int addBook(String name, float price) {
        return jdbcTemplate.update("insert into book value(?,?)",name,price);
    }
    public int delBook(String name) {
        return jdbcTemplate.update("delete from book where name=?",name);
    }
    public int updateBook(String name, float price) {
        return jdbcTemplate.update("update book set price=? where name=?",price,name);
    }
    public List<Book> getAllBook() {
        return jdbcTemplate.query("select * from book", new BookRowMapper());
    }
    public Book getBook(String name) {
        return jdbcTemplate.queryForObject("select * from book where name=?", new BookRowMapper(),name);
    }
    public float getPrice(String name) {
        return jdbcTemplate.queryForObject("select price from book where name=?", Float.class);
    }
kongkongWorld
关注
专栏目录
Spring学习流程
weixin_43795939的博客
07-21 2107
Spring学习目录Spring简介1. 什么是Spring？2. Spring的优势在哪？Spring的快速入门1. Spring的开发步骤2. 代码实现Spring的文件配置1. Bean标签的基本配置2. Bean标签的范围配置3. Bean的生命周期配置4. Bean的三种实例化方法5. Bean的依赖注入入门6. Bean的依赖注入概念7. Bean的依赖注入方式8. Bean的依赖注入的数据类型普通数据类型的注入集合类型的注入9. 引入其他的配置文件(分模块开发)Spring相关的API1. A
AI工程师的自我修养
我的博客
03-09 1676
原创：晏茜 资料来源：Lee AI 行业如今是一个炙手可热的行业，也许有一些正从事或曾经从事于其他行业的同学，希望能有一个更好的职业选择，而 AI 行业正如火如荼的发展，他们想加入 AI 发展的浪潮，也许还有一些已经从事于 AI 行业的同学，想进一步提升自己的个人能力，针对这两类同学的诉求，作者会在正式讲解 AI 工程师的自我修养之前，先介绍 AI 相关的知识和现状，为他们提供参考。所以，前三部分的内容会围绕 AI 相关的知识和现状来展开。首先，会介绍 AI 产业的发展概况和人工智能领域当今主流的技术方向，
spring框架学习过程
weixin_43476690的博客
11-29 426
Springboot框架学习过程 1、Spring Boot——MyBatis配置带下划线命名的字段自动转换驼峰命名解决方案 1.1 问题描述 MyBatis无法查询出属性名和数据库字段名不完全相同的数据。 即：数据库字段和实体bean属性名称不相同时查询出来的数据为null. 1.2 举例 mybatis默认数据库字段要和属性名称完全一致，这样才能匹配，例如 数据库字段：user_name 实体类属性：user_name 但是，一般来说我们java默认的书写习惯是，驼峰命名法，即对于属性名称来说，是将第二
Spring学习过程
xxy1312的博客
06-06 128
Spring 简介 spring：春天—>给软件行业带来了春天 2002，首次推出了Spring框架的雏形：interface21框架！ Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日发布了1.0正式版。 Rod Johnson，Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。 Spring理念：使现有的技术
spring学习过程
01-27
spring基础，主要讲解了 spring的autowire:自动装配 collections:属性配置的细节 properties：外部属性文件的使用 relati：bean之间的关系 scope:bean的作用域 spel：spel的使用
spring学习历程
weixin_43701424的博客
03-31 132
spring学习历程 以下内容，是在学习spring时的记录，希望对你有所帮助，后续持续更新！记得点赞奥！！！ spring中的三种配置方式 1.在spring的配置文件中配置 ，即xml配置，真实开发中使用较多 2.在java中配置，编写配置类，主流的开发使用 3.隐式的自动装配bean，常用的 注解开发，便利高效 spring注解开发 1.导入约束（前期建议官网查询，后期根据导入内容变化，修改对应的连接即可，见下文提示） xmlns="http://www.springframework.org/s
基于Spring+SpringMVC+hibernate实现的体检中心管理系统
mengyu965的博客
02-09 398
源码及论文下载： http://www.byamd.xyz/tag/java/ 摘 要 随着人们生活水平的不断提高,人们的保健意识随之增强,体检已普遍成为人们保健的重要部分。特殊职业的体检、各种职业病的体检、单位职工的群体体检及个人体检使得医院体检人数急剧增加。然而传统的体检工作效率远远不能满足当下剧增的体检业务。所以,医院急需满足健康体检需要的信息管理系统来提高体检工作效率。 本系统包括体检项目管理、预约体检管理、体检套餐管理和体检管理四个部分，可以用户登录注册、预约体检、添加体检项目、设置体检套餐
学习spring源码感想
欧阳惜竹的博客
10-08 473
没事方法不要写那么长 读起来很麻烦，将大的函数按照功能分成多个函数或者多个调用，这样维护和读起来很顺，还能显示水平，也能利于思路的整理 很长的函数： org.springframework.beans.factory.support.ConstructorResolver#autowireConstructor 多个函数调用： org.springframework.beans.factory.s...
Spring知识点全面总结
weixin_44108441的博客
01-05 299
Spring知识点总结   1. 简介一下Spring框架。 答：Spring框架是一个开源的容器性质的轻量级框架。主要有三大特点：容器、IOC（控制反转）、AOP（面向切面编程）。   2. Spring框架有哪些优点？谈谈你的看法。 答：Spring框架主要有三大优点： (1) 容器。Spring框架是一个容器，能够管理项目中的所有对象。 (2) IOC（控制反转）。Sprin...
spring学习心得
08-09
Spring容器的特点 (1)容器对对象的管理 a.创建时机：默认和容器一起创建。 可以使用<bean lazy-init=""/>延缓实例化 可以使用<beans default-lazy-init=""/>延缓所有组件实例化 b.销毁时机：单例对象容器close()负责销毁 c.创建对象的模式（使用范围）：scope控制，可以使用singleton和prototype d.初始化：<bean init-method=""/> e.资源释放：<bean destroy-method=""/>仅对单例对象有效 (2)IoC概念 Inversion of Control 控制反转或控制转移 Don't Call Me，We will call you! 控制权：对象的创建和调用关系的控制. (3)DI概念 Dependecy Injection 依赖注入 Spring 使用DI技术实现了IoC控制。 a.setter注入 b.构造注入 c.接口注入(以后了解)
Spring4快速学习步骤
12-10
本章学习目标  Spring 框架简介  SpringIOC 的概念和作用  工厂模式设计一个简单的IOC 容器  SpringIOC 的XML 方式HelloWorld  SpringIOC 的XML 方式创建对象配置细节  SpringIOC 的XML 方式依赖注入  SpringIOC 的注解方式  Spring 整合Junit 简化测试类编写
Spring基础学习资料，很全面，很经典，手工整理，适合刚学习spring的同学
12-12
Spring基础学习资料，很全面，很经典，手工整理，适合刚学习spring的同学，这是我一边学习以便整理出来的
Spring的学习之路（必看）
m0_56154713的博客
08-13 2456
Spring的学习之路
记录我的Spring学习过程，大神勿看
libo222的博客
07-13 466
我的spring入门学习 1.IOC：  控制反转，就是把对象的创建，初始化，销毁等工作交给spring容器来完成，有spring容器来控制对象的生命周期。 注意： 在将所创建的类放入spring时，是以配置文件的方式放入的。纳入spring容器中之后我们称之为bean。我们通过配置文件进行调用。如下所述：                                 。注意其中class必
Spring的一些心得体会
qq_42183347的博客
01-03 2256
Spring的目的:简化Java开发。 spring框架有非常多的优秀特性，我们总结了以下8点。 1*容器化 容器： Spring 包含 并管理应用中 对象的 生命周期和 配置 （很方便配置是单例 还是 原型 ，以及什么时候使用 什么时候销毁 ） 2* 方便解耦，简化开发 * Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给...
spring5.0学习过程(1)
q568213372的博客
04-06 356
Reactive是spring5.0讲的最多的. Reactive Streams的目的只是建立机制和边界。如果发布者不能减速，则必须决定是缓冲，丢弃还是失败。 我有时也想问,spring mvc和spring webflux关系.为什么有mvc还要spring webflux.官方这张图是很好的解释. 1.1.7。并发模型 Spring MVC和Spring WebFlux都支持带...
Spring基础(很全面）
LucasLi2016的博客
03-16 246
大纲 Spring框架的概述 Spring的快速入门 Spring 工厂接口 在MyEclipse 配置Spring的xml文件提示 IoC容器装配Bean（xml配置方式） Ioc容器装配Bean（注解方式） 在web项目中集成Spring Spring 整合 junit4 测试 1.1 Spring框架学习路线 Spring的Ioc Spring的AOP , AspectJ Spring的事务...
Spring-全面详解（学习总结）
Ray-25
08-12 272
Spring 1.简介 1.1.简介 简介 Spring : 春天 —>给软件行业带来了春天 2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。 2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。 很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。 Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值