第一滴血4,Java技术员务必把握的spring源代码学习的方法!-火竞猜下载-火竞猜下载-火竞猜电子竞技赛事平台

电视电影明星 284℃ 0

Spring简介

Spring 是一个开源结构,是一个分层的 JavaEE 一站式福特房车结构。

所谓一站式结构是指 Spring 有 JavaEE 开发的每一层处理方案。

  • WEB层:SpringMVC
  • Service层:Spring的Bean办理,声明式业务
  • DAO层:Spring的JDBC模板,ORM模板

长处:

  • IOC:便利解耦合
  • AOP:对程序进行扩展
  • 轻量级结构
  • 便利与其他结构整合

Spring运用

Spring开发包解压后的目录介绍:

  • docs: Spring 开发标准和API
  • libs: Spring jar 包和源代码
  • schema: Spring 装备文件的束缚

DataAccess 用于数据拜访,WEB 用于页面显现,中心容器也便是IOC部分。

操控回转(IOC)

操控回转(Inversion of Control)是指将方针的创立权回转(交给)Spring。

运用IOC就需求导入IOC相关的包,也便是上图中中心容器中的几个包:beans,context,core,expression四个包。

完结原理

传统办法创立方针:

UserDAO userDAO=new UserDAO();

进一步面向接口编程,能够多态:

UserDAO userDAO=new UserDAOImpl();

这种办法的缺陷是接口和完结类高耦合,切换底层完结类时,需求修正源代码榜首滴血4,Java技能员有必要掌握的spring源代码学习的办法!-火竞猜下载-火竞猜下载-火竞猜电子竞技赛事渠道。程序设计应该满意OCP元祖,在尽量不修正程序源代码的基础上对程序进行扩展。此刻,能够运用工厂形式:

class BeanFactory{

public static UserDAO getUserDAO(){

return new UserDAOImpl();

}

}

此种办法虽然在接口和完结类之间没有耦合,可是接口和工厂之间存在耦合。

运用工厂+反射+装备文件的办法,完结解耦,这也是 Spring 结构 IOC 的底层完结。

//xml装备文件

//

class BeanFactory{

public static Object getBean(Str仁科百华ing id){

//解析XML

//反射

Class clazz=Class.forName();

return clazz.newInstance();

}

}

IOC XML 开发

在 docs 文件中包括了 xsd-configuration.hmtl 文件。其间界说了 beans schema。

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

调用类:

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");

UserService userService=(UserService)applicationC空气开关ontext.getBean("userService");

userService.save();

IOC 和 DI

DI 指依靠注入,其条件是有必要有 IOC 的环境,Spring 办理这个类的时分将类的依靠的特点注入进来。

例如,在UserServiceImpl.java中:

public class UserServiceImpl implements UserService{

private String name;

public void setName(String nam象棋残局e){

this.name=name;

}

public void save(){

System.out.println("save "+name);

}

}

在装备文件中:

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

测验代码:

@Test

public void demo2(){

//创立Spring工厂

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");

UserServi高瑞良ce userService=(UserService)applicationContext.getBean("userService");

userService.save();

}

运转成果:

save tony

能够看到,在装备文件中装备的特点,在 Spring 办理该类的时分将其依靠的特点成功进行了设置。假如不运用依靠注入,则无法运用接口,只能运用完结类来进行设置,由于接口中没有该特点。

Spring 的工厂类

  • BeanFactory: 老版别的工厂类,在调用getBean()办法时,才会生成类的实例。
  • ApplicationContext: 在加载装备文件的时分,就会将 Spring 办理的类都实例化。有两个完结类:
  1. ClassPathXmlApplicationContext: 加载类途径下的装备文件
  2. FileSystemXmlApplicationContext: 加载磁盘下的装备文件


bean标签装备

  • id: 仅有束缚,不能呈现特别字符
  • name: 理论上能够重复,可是开发中最好不要。能够呈现特别字符


生命周期:

  • init-method: bean被初始化的时分履行的办法
  • destroy-method: bean被毁掉的时分履行的办法


效果规模:

  • scope: bean的效果规模,有如下几种,常用的是前两种
  • singleton: 默许运用单例形式创立
  • prototype: 多例
  • request: 在web项目中,spring 创立类后,将其存入到 request 规模中
  • session: 在web项目中,spring 创立类后,将其存入到 session 规模中
  • globalsession: 在web项目中,有必要用在 天体博客porlet 环境


特点注入设置

  1. 结构办法办法的特点注入: Car 类在结构办法中有两个特点,别离为 name 和 price。

  1. set 办法特点注入: Employee 类在有两个 set 办法,别离设置一般类型的 name 和引证类型的 Car (运用 ref 指向引证类型的 id 或 name)。

  1. P称号空间的特点注入: 首要需求引进p称号空间:

//引进p称号空间

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

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

假如是一般特点:

假如是引证类型:

  1. SpEL(Spring Expression Language)特点注入(Spring 3.x亚洲小说以上版别)


  1. 调集类型特点注入:


qirui

baoma

benchi

多模块开发装备

  1. 在加载装备文件的时分,加载多个装备文件
  2. 在一个装备文件中引进多个装备文件,经过完结


IOC 注解开发

示例

  1. 引进jar包: 除了要引进上述的四个包之外,还需求引进aop包。
  2. 创立 applicationContext.xml ,运用注解开发引进 context 束缚(xsd-configuration.html)

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榜首滴血4,Java技能员有必要掌握的spring源代码学习的办法!-火竞猜下载-火竞猜下载-火竞猜电子竞技赛事渠道">

  1. 组件扫描: 运用IOC注解开发,需求装备组件扫描,也便是哪些包下的类运用IOC的注解。

  1. 在类上增加注解
  2. 运用注解设置特点的值

特点假如有set办法,将特点注入的注解增加到set办法

特点没有set办法,将注解增加到特点上。

@Component("UserDao")//相当于装备了一个 其id为UserDao,对应的类为该类

public class UserDAOImpl implements UserDAO {

@Override

public void save() {

// TODO Auto-generated method stub

System.沈途祝浅绿out.println("save");

}

}

注解详解

  1. @Component

组件注解,用于润饰一个类,将这个类交给 Spring 办理。

有三个衍生的注解,功用相似,也用来润饰类。

  • @Controller:润饰 web 层类
  • @Service:润饰 service 层类
  • @Repository:润饰 dao 层类


2.特点注入

  • 一般特点运用 @Value 来设置特点的值
  • 方针特点运用 @Autowired ,这个注解是依照类型来进行特点注入的。假如期望依照 bean 的称号或id进行特点注入,需求用 @Autowired 和 @Qualifier 一同运用
  • 实践开发中,运用 @Resource(name=" ") 来进行依照方针的称号完结特点注入


3.其他注解

  • @PostConstruct 相当于 init-method,用于初始化函数的注解
  • @PreDestroy 相当于 destroy-method,用于毁掉函数的注解
  • @Scope 效果规模的注解,常用的是默许单例,还有多例 @Scope("prototype")

IOC 的 XML 和注解开发比较

  • 适用场景:XML 适用于任何场景;注解只合适自己写的类,不是自己供给的类无法增加注解。
  • 能够运用 XML 办理 bean,运用注解来进行特点注入

AOP开发

AOP 是 Aspect Oriented Programming 的缩写,意为面向切面编程,经过预编译办法和运转期动态署理完结程序功用的共同保护的一种技能,是OOP的连续。

AOP 能够对程序进行增强,在不修正源码的情况下,能够进行权限校验,日志记载,功用监控,业务操控等。

也便是说功用分为两大类,一类是中心业务功用,一类是辅佐增强功用。两类功用互相独立进行开发。比方登录功用是中心业务功用,日志功用是辅佐增强功用,假如有需求,将日志和登录编制在一同。辅佐功用就称为切面,这种能选择性的、低耦合的把切面和中心业务功用结合的编程思维称为切面编程。

底层完结

JDK 动态署理只能对完结了接口的类发生署理。Cglib 动态署理能够对没有完结接口的类发生署理方针,生成的是子类方针。

运用 JDK 动态署理:

public interface UserDao {

public void insert();

public void delete();

public void update();

public void query();

}

完结类:

public class UserDaoImpl implements UserDao {

@Override

public void insert() {

System.out.println("insert");

}

@Override

public void delete() {

System.out.println("delete")阿格内尔;

}

@Override

public void update() {

System.out.println("update");

}

@Override

public void query() {

System.out.println("query");

}

}

JDK 署理:

public class JDKProxy implements InvocationHandler{

private UserDao userDao;

public JDKProxy(UserDao userDao){

this.userDao=userDao;

}

public UserDao createProxy(){

UserDao userDaoProxy=(UserDao)Proxy.newProxyInstance(userDao.getClass().getClassLoader(),

userDao.getClass().getInterfaces(), this);

return userDaoProxy;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throw应该able {

if("update".equals(method.getName())){

System.out.println("权限校验");

return method.invoke(userDao, args);

}

return method.invoke(userDao, args);

}

}

经过动态署理增强了 update 函数。 测验类:

public class Demo1 {

@Test

public void demo1(){

UserDao userDao=new UserDaoImpl();

UserDao proxy=new JDKProxy(userDao).createProxy();

proxy.insert();

proxy.delete();

proxy.update();

proxy.query();

}

}

运转成果为:

insert

delete

权限校验

update

query

CglibCglib 是第三方开源代码生成类库,能够动态增加类的特点和办法。

与上边JDK署理不同,Cglib的运用办法如下:

public class CglibProxy implements MethodInterceptor{

//传入增强的方针

private UserDao customerDao;

public CglibProxy(UserDao userDao){

this.userDao=userDao;

}

public UserDao createProxy(){

Enhancer enhancer=new Enhancer();

enhanc伍露茜er.setSuperclass(userDao.getClass());

enhancer.setCallback(this);

UserDao proxy=(UserDao)enhancer.create();

return proxy;

}

@Override

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

if("save".equals(method.getName())){

System.out.println("enhance function");

return methodProxy.invokeSuper(proxy, args);

}

return methodProxy.invokeSuper(proxy, args);

}

}

假如完结了接口的类,底层选用JDK署理。假如不是完结了接口的类,底层选用 Cglib署理。

IOC与传统办法的比较

  1. 获取方针办法:传统经过 new 要害字主动创立一个方针。IOC 办法中,将方针的生命周期交给 Spring 办理,直接从 Spring 获取方针。也便是操控回转————将操控权从自己手中交到了 Spring 手中。

Spring 的 AOP 开发(AspectJ 的 XML 办法)

AspectJ 是一个 AOP 的结构,Spring 引进 AspectJ,依据 AspectJ 进行 AOP 的开发。

相关术语

  • Joinpoint: 连接点,能够被阻拦到的点。也便是能够被增强的办法都是连接点。
  • Pointcut: 切入点,真正被阻拦到的点,也便是真正被增强的办法
  • Advice: 告诉,办法层面的增强。对某个办法进行增强的办法,比方对 save 办法进行权限校验,权限校验的办法称为告诉。
  • Introduction: 引介,类层面的增强。
  • Target: 方针,被增强的方针(类)。
  • Weaving: 织入,将 advice 应用到 target 的进程。
  • Proxy: 署理方针,被增强的方针。
  • Aspect: 切面,多个告诉和多个切入点的组合。


运用办法

  1. 引进相关包
  2. 引进装备文件

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

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

  1. 编写方针类并装备:

public class ProductDaoImpl implements ProductDao {

@Override

public void save() {

System.out.println("save");

}

@Override

public void update() {

System.out.println("upd榜首滴血4,Java技能员有必要掌握的spring源代码学习的办法!-火竞猜下载-火竞猜下载-火竞猜电子竞技赛事渠道ate");

}

@Override

public void find() {

System.out.println("find");

}

@Override

public void delete() {

System.out.println("delete");

}

}

  1. 编写切面类,假定用于权限验证并装备

public class MyAspectXML {

public void ch纸杯蛋糕eckPri(){

System.out.println("check auth");

}

}

  1. 经过AOP装备完结对方针类的增强

告诉类型

  1. 前置告诉:在方针办法履行前操作,能够获得切入点信息

public void checkPri(JoinPoint joinPoint){

System.out.println("check auth "+joinPoint);

}

  1. 后置告诉:在方针办法履行后操作,能够获得办法回来值


public void writeLog(Object result){

System.out.println("writeLog "+result);

}

  1. 盘绕告诉:在方针办法履行前和后操作,能够阻挠方针办法履行

public Object around(ProceedingJoinPoint joinPoint) throws Throwable{

System.out.println("before");

Object result=joinPoint.proceed();

System.out.println("after");

return result;

}

  1. 反常抛出告诉:程序呈现反常时操作

public void afterThrowing(Throwable ex){

System.out.println("exception "+ex.getMessage());

}

  1. 终究告诉:相当于finally块,不管代码是否有反常,都会履行


public void finallyFunc(){

System.out.println("finally");

}

  1. 引介告诉:不常用

Spring 切入点表达式

依据 execution 函数完结

语法:[拜访润饰符] 办法回来值 包名.类名.办法名(参数)

其间恣意字段能够运用*替代表明恣意值

Spring 的 AOP 依据 AspectJ 注解开发

开发进程

  1. 引进ja榜首滴血4,Java技能员有必要掌握的spring源代码学习的办法!-火竞猜下载-火竞猜下载-火竞猜电子竞技赛事渠道r包
  2. 设置装备文件:


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"

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

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

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx.xsd">

  1. 编写装备方针类

public class OrderDao {

public void save(){

System.out.println("save order");

}

public void update(榜首滴血4,Java技能员有必要掌握的spring源代码学习的办法!-火竞猜下载-火竞猜下载-火竞猜电子竞技赛事渠道){

System.out.println("update order");

}

public void delete(){

System.out.println("delete order");

}

public void find(电解质){

System.out.println("find order");

}

}

  1. 敞开aop注解主动署理


  1. 编写切面类并装备

@Aspect

public class MyAspectAnno {

@Before(value="execution(* demo1.OrderDao.save(..))")

public void before(){

System.out.println("before");

}

}

注解告诉类型

  • @Before: 前置告诉
  • @AfterReturning: 后置告诉

@AfterReturning(value="execution(* demo1.OrderDao.save(..))",returning="result")

public void after(Object result){

System.out.println("after "+result);

}

  • @Around:盘绕告诉

@Around(value="execution(* demo1.OrderDao.save(..))")

public Object around(ProceedingJoinPoint joinPoint) throws Throwable{

System.out.println("before");

Object obj=joinPoint.proceed();

System.out.println("after");

return obj;

}

  • @AfterThrowing: 抛出反常


@AfterThrowing(value="execution(* demo1.OrderDao.save(..))",throwing="e")

public榜首滴血4,Java技能员有必要掌握的spring源代码学习的办法!-火竞猜下载-火竞猜下载-火竞猜电子竞技赛事渠道 void afterThrowing(Throwable e){

System.out.println("exception:"+e.getMessage();

}

  • @After: 终究告诉

@After(value="execution(* demo1.OrderDao.save(..))")

public void after(){

System.out.println("finally");

}

  • @PointCut:切入点注解


@PointCut(value="execution(* demo1.OrderDao.save(..))")

private void pointcut1(){}

此刻,在上述告诉的注解中,value能够替换为该函数名,例如:

@After(value="MyAspect.pointcut1()")

public void after(){

System.out.println("finally");

}

这个注解的优点是,只需求保护切入点即可,不用在修正时修正每个注解。

Spring 的 JDBC 模板

Spring 对耐久层也供给了处理方案,也便是 ORM 模块和 JDBC 的模板。针对 JDBC ,供给了 org.springframework.jdbc.core.JdbcTemplate 作为模板类。

运用 JDBC 模板

  1. 引进jar包,数据库驱动,Spring 的 jdbc 相关包。
  2. 根本运用:

public void demo1(){

//创立连接池

DriverManagerDataSource dataSource=new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.jdbc.Driver");

dataSource.setUrl("jdbc:mysql:///spring4");

dataSource.setUsername("root");

dataSource.setPassword("123456");

//创立JDBC模板

JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);

jdbcTemplate.update("insert into account values (null,?,?)", "xiaoming",1000d);

}

  1. 将连接池和模板交给 Spring 办理
  • 装备文件:


  • 测验文件:

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class JdbcDemo2 {

@Resource(name="jdbcTemplate")

private JdbcTemplate jdbcTemplate;

@Test

public void demo2(){

jdbcTemplate.update("壹钱包insert into account values (null,?,?)", "xiaolan",1000d);

}

}

运用开源数据库连接池

  1. 运用 DBCP 的装备:


  1. 运用 C3P0 的装备:

  1. 引进外部特点文件

首要树立外部特点文件:

jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://192.168.66.128/spring4

jdbc.username=root

jdbc.password=123456

然后对特点文件进行装备:

CRUD操作

insert, update, delete 句子都凭借模板的 update 办法进行操作。

public void demo(){

jdbcTemplate.update("insert into account values (null,?,?)", "xiaoda",1000d);

jdbcTemplate.update("update account set name=?,money=? where id=?", "xiaoda",1000d,2);

jdbcTemplate.update("delete from account where id=?", 6);

}

查询操作:

public void demo3(){

String name=jdbcTemplate.queryForObject("select name from account where id=?",String.class,5);

long count=jdbcTemplate.queryForObject("select count(*) from account",Long.class);

}

将回来的成果封装成为类:

public void demo4(){

Account account=jdbcTemplate.queryForObject("select * from account where id=?", new MyRowMapper(),5);

}

其间:

class MyRowMapper implements RowMapper{

@Override

public Account mapRow(ResultSet rs, int rowNum) throws SQLException {

Account account=new Account();

account.setId(rs.getInt("id"));

account.setName(rs.getString("name"));

account.setMoney(rs.getDouble("money"));

return account;

}

}

Spring的业务办理

业务

业务是指逻辑上的一组操作,组成这组操作的各个单元,要么悉数成功,要么悉数失利。

具有四个特性:

  • 原子性:业务不可分
  • 共同性:业务履行前后数据完整性保持共同
  • 阻隔性:一个业务的履行不应该遭到其他业务搅扰
  • 耐久性:一旦业务完毕,数据就耐久化到数据库


假如不考虑阻隔性会引发安全性问题:

  • 读问题:
  • 脏读:一个业务读到另一个业务未提交的数据
  • 不可重复读:一个业务读到另一个业务现已提交的 update 数据,导致一个业务中屡次查询成果不共同
  • 幻读:一个业务读到另一个业务现已提交的 insert 数据,导致mhxx要害使命一个业务中屡次查询成果不共同


  • 写问题:
  • 丢掉更新


处理读问题:设置业务阻隔等级

  • Read团子 uncommitted: 未提交读,无法处理任何读问题
  • Read committed: 已提交读,处理脏读问题
  • Repeatable read: 重复读,处理脏读和不可重复读问题
  • Serializable:序列化,处理一切读问题


业务办理API

  1. PlatformTransactionManager: 渠道业务办理器

这是一个接口,具有多个不同的完结类,如 DataSourceTransactionManager 底层运用了JDBC 办理业务; HibernateTransactionManager 底层运用了 Hibernate 办理业务。

  1. TransactionDefinition: 业务界说信息


用于界说业务的相关信息,如阻隔等级、超时信息、传达行为、是否只读等

  1. TransactionStatus: 业务的状况


用于记载在业务办理进程中,业务的状况的方针。

上述API的联系: Spring 在进行业务办理的时分,首要渠道业务办理器依据业务界说信息进行业务办理,在业务办理进程傍边,发生各种此状况,将这些状况信息记载到业务状况的方针傍边。

业务的传达行为

业务的传达行为首要处理业务层(Service)办法彼此调用的问题,也便是不同的业务中存在不同的业务时,怎么操作。

Spring 中供给了7种业务的传达行为,分为三类:

  • 确保多个操作在同一个业务中
  • PROPAGATION_REQUIRED: B办法调用A办法,假如A中有业务,运用A中的业务并将B中的操作包括到该业务中;不然新建一个业务,将A和B中的操作包括进来。(默许)
  • PROPAGATION_SUPPORTS:假如A中有业务,运用A的业务;不然不运用业务
  • PROPAGATION_MANDATORY:假如A中有业务,运用A的业务;不然抛出反常


  • 确保多个操作不在同一个业务中
  • PROPAGATION_REQUIRES_NEW:假如A中有业务,将其挂起,创立新业务,只包括本身操作。不然,新建一个业务,只包括本身操作。
  • PROPAGATION_NOT_SUPPORTED:假如A中有业务,挂起,不运用业务。
  • PROPAGATION_NEVER:假如A中有业务,抛出反常,也即不能用业务运转。


  • 嵌套业务
  • PROPAGATION_NESTED:假如A有业务,依照A的业务履行,履行完结后,设置一个保存点,然后履行B的操作。假如出毛晓舟现反常,能够回滚到开始状况或保存点状况。


实例

以转账为例,业务层的DAO层类如下:

public interface AccountDao {

public void outMoney(String from,Double money);

public void inMoney(String to,Double money);

}

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{

@Override

public void outMoney(String from, Double money) {

this.getJdbcTemplate().update("update account set money = money - ? where name = ?",money,from);

}

@Override

public void inMoney(String to, Double money) {

thi滑滑梯s.getJdbcTemplate().update("update account set money = money + ? where name = ?",money,to);

}

}

public interface AccountService {

public void transfer(String from,String to,Double money);

}

public class AccountServiceImpl implements AccountService {

private AccountDao accountDao;

public void setAccountDao(AccountDao accountDao) {

this.accountDao = accountDao;

}

@Override

public void transfer(String from, String to, Double money) {

accountDao.outMoney(from, money);

accountDao.inMoney(to, money);

}

}

在xml中进行类的装备:

业务办理1: 编程式业务办理

  1. 装备渠道业务办理器


  1. 装备业务办理模板类


  1. 在业务层注入业务办理模板

  1. 编码完结业务办理


//ServiceImpl类中:

private TransactionTemplate transactionTemplate;

@Override

public void transfer(String from, String to, Double money) {

transactionTemplate.execute(new TransactionCallbackWithoutResult() {

@Override

protected void doInTransactionWithoutResult(TransactionStatus arg0) {

accountDao.outMoney(from, money);

accountDao.inMoney(to, money);榜首滴血4,Java技能员有必要掌握的spring源代码学习的办法!-火竞猜下载-火竞猜下载-火竞猜电子竞技赛事渠道

}

});

}

声明式业务办理(装备完结,依据AOP思维)

  1. XML 办法的声明式业务办理
  • 装备业务办理器


  • 装备业务告诉


  • 装备a注册qqop业务


  1. 注解办法
  • 装备业务办理器,和上方共同
  • 敞开业务办理的注解:

  • 在运用业务的类上增加一个注解@Transactional