简 单 就 是 幸 福
简 单 就 是 幸 福

SpringAOP以及事务管理和优化处理

Spring的AOP

本篇章中所有的代码都将会放置到git仓库中去，并且会做一个简要的说明。

一、个人理解描述

Spring中所谓的AOP就是在不修改源码的情况下，来进行增强。所谓的增强其实就是在方法执行前后添加一些额外操作。

所谓的增强，就是我们如何来对方法（以类中的方法为基本单位）处理。处理方法有五种：前置增强、后置增强等等

但是最为常用的还是利用环绕通知来进行增强，习惯于手动控制，更加精细化操作。

简单利用画图说明一下上面的描述：

SpringAOP以及事务管理和优化处理_第1张图片

以这里的CourseController和UserController为例，希望在CourseService和UserService类中的每个都开始事务操作，而且还不在修改CourseService和UserService类中源码的情况下来进行操作，不破坏原来的代码的完整性。

那么首先来写个简单的Demo来体验一下SpringAOP的强大之处。

二、案例演示

  • 希望只针对UserServiceImpl类中的save无参方法来做日志打印处理。

因为工作中需要，需要利用到注解+xml的方法，所以下面没有提供纯注解的方式来进行操作。

在UserService接口中提供了三个方法来模拟实际开发过程中接口中的方法：

public interface UserService {
    void save();
    void save(String name);
    void save(String name, Integer age);
}

UserServiceImpl是对接口UserService的实现：

@Service("userService")
public class UserServiceImpl implements UserService {
    @Override
    public void save() {
        System.out.println("UserService.save()");
        try {
            int randomMs = (int) (Math.random()*1000);
            Thread.sleep(randomMs);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void save(String name) {
        System.out.println("UserService.save(String)");
    }

    @Override
    public void save(String name, Integer age) {
        System.out.println("UserService.save(String, Integer)");
    }
}

上面两步操作中是最为简单的！下面就要来为我们的save无参方法来进行增强。

所谓的增强，就是调用save无参方法的时候，打印我们的日志。

那么来写一个增强类即可：

@Component
public class MyAdvice {

    /**
     * 环绕通知方法。调用者调用时，Spring会执行这个环绕通知方法
     * @param pjp 由Spring传递进来的切入点对象（目标方法、目标对象、方法实参等等封装成的对象）
     * @return
     */
    public Object aroundMethod(ProceedingJoinPoint pjp){
        Object result = null;
        try {
            System.out.println("调用业务方法之前，我希望看下是否已经走了动态代理");
            long start = System.currentTimeMillis();
            //自己调用目标对象，得到返回值
            // 固定写法：调用业务方法-----所以上面的逻辑可以称之为在调用方法之前操作
            result = pjp.proceed(pjp.getArgs());
            // 下面的逻辑可以表示成调用业务逻辑方法之后的操作
            System.out.println("调用业务方法之后，我希望看下业务方法执行之后的结果");
            long end = System.currentTimeMillis();
            System.out.println("当前业务方法调用过程中花费的是时间有：" + (end - start) + "毫秒");
        } catch (Throwable throwable) {
            System.out.println("当前方法抛出异常，对应的异常是："+throwable);
        } finally {
            System.out.println("无论业务方法执行过程中出现了怎样的问题，那么这行代码最终都要来执行");
        }
        // 返回最终结果
        return result;
    }
}

因为利用到的是注解+xml的方式，所以再写一个xml来配置扫描类和动态代理生成过程：


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       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/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">
	
    <context:component-scan base-package="com.guang.service.impl"/>
    <context:component-scan base-package="com.guang.advice"/>
    
    
    <aop:config>
        <aop:aspect ref="myAdvice">
            <aop:around method="aroundMethod" pointcut="execution(public void com.guang.service..UserServiceImpl.save())"/>
        aop:aspect>
    aop:config>
beans>

那么来写一段代码测试：

public class XmlAopTest {
    @Test
    public void test(){
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");

        UserService userService = app.getBean("userService", UserService.class);
        userService.save();
        System.out.println("---------------------");
        userService.save("tom");
        System.out.println("---------------------");
        userService.save("tom", 20);
    }
}

打印结果如下所示：

调用业务方法之前，我希望看下是否已经走了动态代理
UserService.save()
调用业务方法之后，我希望看下业务方法执行之后的结果
当前业务方法调用过程中花费的是时间有：838毫秒
无论业务方法执行过程中出现了怎样的问题，那么这行代码最终都要来执行
---------------------
UserService.save(String)
---------------------
UserService.save(String, Integer)

从这里可以看到，尽管利用userService调用了三个无参方法，但是只有save无参方法进行了增强。那么到底是如何做到的呢？

下面我们先介绍概念，然后从概念来进行入手，着手分析，然后再进行分析。

三、AOP相关的概念

3.1、AOP相关概念

  • 目标对象(Target)：要代理的/要增强的目标对象。

  • 代理对象(Proxy)：目标对象被AOP织入增强后，就得到一个代理对象

  • 连接点(JoinPoint)：能够被拦截到的点，在Spring里指的是方法

    目标类里，所有能够进行增强的方法，都是连接点

  • 切入点(PointCut)：要对哪些连接点进行拦截的定义

    已经增强的连接点，叫切入点

  • 通知/增强(Advice)：拦截到连接点之后要做的事情

    对目标对象的方法，进行功能增强的代码

  • 切面(Aspect)：是切入点和通知的结合

  • 织入(Weaving)：把增强/通知 应用到 目标对象来创建代理对象的过程。Spring采用动态代理技术织入，而AspectJ采用编译期织入和装载期织入

那么画图来描述一下，我觉得更为稳妥，如下所示：

SpringAOP以及事务管理和优化处理_第2张图片

以例子来进行说明：

  • 目标对象：就是courseservice所表示的单例对象；

  • 代理对象：就是需要对courseservice对应的单例对象来进行代理的对象；

  • 所谓的连接点：以上面的courseservice来举例，可以认为是courseservice类中的所有方法；

  • 所谓的切入点：就是我们需要筛选courseservice类中的个别方法来作为特殊的点（如何筛选，那么就需要我们手写point表达式来进行选择）；

  • 增强：所谓的增强就是要对原来的方法来做何种操作；

  • 切面：切入点+增强；

3.2、AOP开发前要明确的事项
我们要做的事情：
  • 编写核心业务代码（Target目标类的目标方法）
  • 编写通知类，通知类中有通知方法（Advice增强功能方法）
  • 在配置文件中，配置织入关系，即将哪些通知与哪些切入点 结合，形成切面
Spring的AOP做的事情：
  • 生成动态代理的过程（把通知织入到切入点的过程），是由Spring来实现的
  • Spring会监控切入点方法的执行，一旦发现切入点方法执行，使用代理机制动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。
小结
  • AOP相关的概念/术语
    • 目标类Target：要对哪个类进行增强
    • 代理对象Proxy：对目标类增强后的那个代理对象
    • 连接点JoinPoint：目标类里可增强的方法
    • 切入点PointCut：要增强的方法
    • 通知Advice：功能增强的代码
    • 切面Aspect：切入点 + 通知
    • 织入Weaving：把切入点 和 通知 进行结合，生成代理对象的过程
  • 使用AOP，我们要做的事情：
    • 编写目标类，自己的业务代码
    • 编写通知类
    • 配置切面
  • 使用AOP，Spring做的事情
    • 根据我们配置的切面，进行织入生成代理对象

四、基于XML的AOP

快速入门
1) 需求描述
  • 有目标类UserServiceImpl，有通知类MyAdvice
  • 使用XML方式AOP，对目标类UserServiceImpl的方法进行增强
2) 步骤分析
  1. 创建maven项目，导入AOP相关的依赖坐标
  2. 创建目标类（要增强的类，内部有切入点），创建通知类（内部有增强的方法代码）
  3. 修改配置文件：
    1. 把目标类和通知类都配置成为bean对象
    2. 配置切入点和通知方法(增强方法)的织入关系：配置切面
  4. 测试代码
3) 入门实现
1. 创建maven项目，导入坐标
<dependencies>
    
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.0.2.RELEASEversion>
    dependency>
    
    <dependency>
        <groupId>org.aspectjgroupId>
        <artifactId>aspectjweaverartifactId>
        <version>1.8.9version>
    dependency>
    
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.0.2.RELEASEversion>
    dependency>
    
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>
dependencies>
2. 创建目标类和通知类
  • 目标类：com.guang.aop.UserServiceImpl
public class UserService{
    void save();
}

public class UserServiceImpl {
    public void save(){
        System.out.println("UserServiceImpl.save......");
    }
}
  • 通知类：com.guang.aop.MyAdvice
public class MyAdvice {
    public void before(){
        System.out.println("前置通知...");
    }
}
3. 修改配置文件
  1. 把目标类和通知类都配置到Spring配置文件中
  2. 配置切入和通知方法(增强方法)的织入关系

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    
    <bean id="userService" class="com.guang.service.impl.UserServiceImpl"/>
    
    <bean id="myAdvice" class="com.guang.aop.MyAdvice"/>
    
    <aop:config>
        
        <aop:aspect ref="myAdvice">
            
            <aop:before method="before" pointcut="execution(void com.guang.service.impl.UserServiceImpl.save())"/>
        aop:aspect>
    aop:config>
beans>

注意：在xml中增加了aop的名称空间如下：

SpringAOP以及事务管理和优化处理_第3张图片

4. 测试代码
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private UserService userService;

    @Test
    public void testQuickStart(){
        userService.save();
    }
}
4) 步骤小结
  1. 导入jar包：spring-context, aspectjweaver
  2. 编写目标类、编写通知类
  3. 配置切面
<aop:config>
	<aop:aspect ref="通知对象">
        <aop:before method="通知对象里的通知方法" pointcut="切入点表达式"/>
    aop:aspect>
aop:config>
AOP详解
1) 切点表达式的写法
语法：
execution([权限修饰符] 返回值类型 包名.类名.方法名(参数列表))
  • 修饰符：可以省略
  • 返回值类型：
    • 可以指定类型。比如String （如果类型有歧义，就写全限定类名，比如：java.util.Date）
    • *，表示任意字符。比如Str*，或者*
  • 包名：
    • 可以写.：表示当前包下的类或者子包。比如com.guang.service
    • 可以写..：表示当前包里所有后代类、后代包。比如com..service
    • *：表示任意字符。比如：com.gua*, com.*
  • 类名：
    • 可以指定类名。比如：UserServiceImpl
    • * 表示任意字符。比如：*ServiceImpl，*
  • 方法名：
    • 可以指定方法名
    • * 表示任意字符。比如：save*，*
  • 参数列表：
    • 可以指定类型。比如：String,Integer表示第一个参数是String，第二个参数是Integer类型
    • *表示任意字符。比如：
      • String, * 表示第一个参数是String，第二个参数是任意类型
      • Str*, Integer表示第一个参数类型Str开头，第二个参数是Integer类型
    • 可以使用..表示任意个数、任意类型的参数
示例
execution(public void com.guang.dao.impl.UserDao.save())
execution(void com.guang.dao.impl.UserDao.*(..))
execution(* com.guang.dao.impl.*.*(..))
execution(* com.guang.dao..*.*(..))
execution(* *..*.*(..)) --不建议使用
2) 通知的种类
通知的语法
<aop:通知类型 method="通知中的方法" pointcut="切点表达式">aop:通知类型>
通知的类型
名称 标签 说明
前置通知 通知方法在切入点方法之前执行
后置通知 在切入点方法正常执行之后，执行通知方法
异常通知 在切入点方法抛出异常时，执行通知方法
最终通知 无论切入点方法是否有异常，最终都执行通知方法
环绕通知 通知方法在切入点方法之前、之后都执行
通知示例

注意：通知方法的名称随意，我们这里是为了方便理解，才起名称为：before, after等等

  • 前置通知

    • 通知方法定义MyAdvice的before方法：
    public void before(){
    System.out.println("前置通知");
}
    • xml配置
    <aop:before method="before" 
            pointcut="execution(void com.guang.service..*.save())"/>

  • 后置通知

    • 通知方法定义
    public void afterReturning(){
    System.out.println("后置通知");
}
    • xml配置
    <aop:after-returning method="afterReturning" 
                     pointcut="execution(void com.guang.service..*.save())"/>

  • 环绕通知

    • 通知方法定义
    /**
 * @param pjp ProceedingJoinPoint：正在执行的切入点方法对象
 * @return 切入点方法的返回值
 */
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("环绕：前置通知...");

    Object[] args = pjp.getArgs();
    //切入点方法执行
    Object proceed = pjp.proceed(args);

    System.out.println("环绕：后置通知...");

    return proceed;
}
    • xml配置
    <aop:around method="around" 
            pointcut="execution(void com.guang.service..*.save())"/>

  • 异常抛出通知

    • 通知方法定义
    public void afterThrowing(){
    System.out.println("抛出异常通知");
}
    • xml配置
    <aop:after-throwing method="afterThrowing" 
                    pointcut="execution(void com.guang.service..*.save())"/>

  • 最终通知

    • 通知方法定义
    public void after(){
    System.out.println("最终通知");
}
    • xml配置
    
<aop:config>
    
    <aop:pointcut id="myPointCut" 
                  expression="execution(void com.guang.service..*.save())"/>
    
    <aop:aspect ref="myAdvice">
        
        <aop:before method="before" pointcut-ref="myPointCut"/>
        
        <aop:after-returning method="afterReturning" pointcut-ref="myPointCut"/>
        
        <aop:after-throwing method="afterThrowing" pointcut-ref="myPointCut"/>
        
        <aop:after method="after" pointcut-ref="myPointCut"/>
    aop:aspect>
aop:config>
4) 小结
  • 需要我们编写的内容：
    • 编写目标类，编写通知类
    • 配置切面
<aop:config>
	<aop:pointcut id="xxx" expression="切入点表达式"/>
    <aop:aspect ref="通知对象">
        <aop:before method="通知对象里的通知方法" pointcut-ref="xxx"/>
        <aop:after-returning method="通知对象里的通知方法" pointcut-ref="xxx"/>
        <aop:after-throwing method="通知对象里的通知方法" pointcut-ref="xxx"/>
        <aop:after method="通知对象里的通知方法" pointcut-ref="xxx"/>
        
        <aop:around method="通知对象里的通知方法" pointcut-ref="xxx"/>
    aop:aspect>
aop:config>
  • 注意环绕通知的方法
public Object aroundMethod(ProceedingJoinPoint pjp){
	Object reuslt = null;
    
    try{
        //写前置通知代码
        
        //调用目标对象的方法
    	result = pjp.proceed(pjp.getArgs());
        
        //写后置通知代码
    }catch(Throwable t){
        //写异常通知代码
    }finally{
        //写最终通知代码
    }
}

五、基于注解的AOP

快速入门
1) 需求描述
  • 有目标类UserServiceImpl，有通知类MyAdvice
  • 使用注解方式的AOP对目标类UserServiceImpl的方法进行增强
2) 步骤分析
  1. 创建maven项目，导入AOP需要的依赖坐标
  2. 创建目标类，创建通知类
    1. 使用注解@Component标注两个类，配置成为bean对象
    2. 在通知类中，使用注解配置织入关系
  3. 在配置文件中，开启组件扫描和AOP的自动代理（自动装配）
  4. 测试
3) 入门实现
1. 创建maven项目，导入坐标
  • 注意：需要增加AOP的实现包：aspectjweaver
<dependencies>
    
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.0.2.RELEASEversion>
    dependency>
    
    <dependency>
        <groupId>org.aspectjgroupId>
        <artifactId>aspectjweaverartifactId>
        <version>1.8.9version>
    dependency>
    
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.0.2.RELEASEversion>
    dependency>
    
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>
dependencies>
2. 创建目标类，创建通知类

  1. 使用注解标注两个类，配置成为bean对象

    • 实际开发中，使用@Repository, @Service, @Controller注解，按照分层进行配置

  2. 在通知类中，使用注解配置织入关系

    • 目标类com.guang.aop.Target
    public class UserService{
    void save();
}

    @Service("userService")
public class UserServiceImpl {
    public void save(){
        System.out.println("UserServiceImpl.save......");
    }
}
    • 通知类com.guang.aop.MyAdvice
    import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//声明当前类是切面类：把切入点和通知，在这个类里进行织入，当前类就成为了一个切面类
@Aspect 
@Component("myAdvice")
public class MyAdvice {

    @Before("execution(void com.guang.impl..*.save())")
    public void before(){
        System.out.println("前置通知...");
    }

    @AfterReturning("execution(void com.guang.impl..*.save()))")
    public void afterReturning(){
        System.out.println("后置通知");
    }

    @After("execution(void com.guang.impl..*.save())")
    public void after(){
        System.out.println("最终通知");
    }

    @AfterThrowing("execution(void com.guang.impl..*.save())")
    public void afterThrowing(){
        System.out.println("抛出异常通知");
    }

    /**
     * @param pjp ProceedingJoinPoint：正在执行的切入点方法对象
     * @return 切入点方法的返回值
     */
    @Around("execution(void com.guang.impl..*.save())")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕：前置通知...");

        //切入点方法执行
        Object proceed = pjp.proceed();

        System.out.println("环绕：后置通知...");

        return proceed;
    }
}
4. 开启组件扫描和AOP自动代理
  • 在applicationContext.xml中

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
       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">

    
    <context:component-scan base-package="com.guang"/>

    
    <aop:aspectj-autoproxy/>
beans>

如果要使用纯注解开发，可以使用配置类代替applicationContext.xml，配置类如下：

@Configuration //标记当前类是：配置类
@ComponentScan(basePackage="com.guang") //配置注解扫描
@EnableAspectJAutoProxy //开启AOP自动代理
public class AppConfig{   
}
5. 测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {

    @Autowired
    private UserService userService;

    @Test
    public void testQuickStart(){
        userService.save()
    }
}
4) 步骤小结
AOP详解
1) 通知的种类
通知的语法
@通知注解("切入点表达式")
通知的类型
名称 注解 说明
前置通知 @Before 通知方法在切入点方法之前执行
后置通知 @AfterRuturning 通知方法在切入点方法之后执行
异常通知 @AfterThrowing 通知方法在抛出异常时执行
最终通知 @After 通知方法无论是否有异常，最终都执行
环绕通知 @Around 通知方法在切入点方法之前、之后都执行
  • 注意：
    • 注解方式配置的通知，执行顺序是：前置->最终->后置/异常
    • 如果想要指定执行的顺序，就使用环绕通知
2) 切点表达式的抽取
  • 同xml的AOP一样，当多个切面的切入点表达式相同时，可以将切入点表达式进行抽取；
  • 抽取方法是：
    • 在增强类(切面类，即被@Aspect标的类)上增加方法，在方法上使用@Pointcut注解定义切入点表达式，
    • 在增强注解中引用切入点表达式所在的方法
  • 示例：
@Aspect
@Component("myAdvice1")
public class MyAdvice1 {

    //定义切入点表达式
    @Pointcut("execution(void com.guang.service..*.save())")
    public void myPointcut(){}

    //引用切入点表达式
    //完整写法：com.guang.aop.MyAdvice.myPointcut()
    //简单写法：myPointcut(), 引入当前类里定义的表达式，可以省略包类和类名不写
    @Before("myPointcut()")
    public void before(){
        System.out.println("前置通知...");
    }
   
    @AfterReturning("myPointcut()")
    public void afterReturning(){
        System.out.println("后置通知");
    }

    @After("myPointcut()")
    public void after(){
        System.out.println("最终通知");
    }

    @AfterThrowing("myPointcut()")
    public void afterThrowing(){
        System.out.println("抛出异常通知");
    }

    /*@Around("myPointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("前置通知...");

        //切入点方法执行
        Object proceed = pjp.proceed();

        System.out.println("后置通知...");

        return proceed;
    }*/
}
3) 小结
  1. 在通知类上加注解@Aspect，声明成一个切面
  2. 在通知类里方法上加注解@Before/@AfterReturning/@AfterThrowing/@After/@Around，配置切入点表达式
  3. 在xml里开启aop的自动代理：

六、纯注解的AOP

  • 主要是把XML的配置，放到核心配置类上
@Configuration
@ComponentScan(basePackages="com.guang")//开启组件扫描
@EnableAspectJAutoProxy //开启AOP的自动代理
public class AppConfig{
    
}

@Aspect
@Component("myAdvice2")
public class MyAdvice2 {

    //定义切入点表达式
    @Pointcut("execution(void com.guang.service..*.save())")
    public void myPointcut(){}

    @Before("myPointcut()")
    public void before(){
        System.out.println("前置通知...");
    }
   
    @AfterReturning("myPointcut()")
    public void afterReturning(){
        System.out.println("后置通知");
    }

    @After("myPointcut()")
    public void after(){
        System.out.println("最终通知");
    }

    @AfterThrowing("myPointcut()")
    public void afterThrowing(){
        System.out.println("异常通知");
    }
}

七、Spring事务管理

在Spring事务管理中，我推荐使用的是编程式事务，而不是声明式事务。

所谓的编程式事务就是我们手动来控制事务，而声明式事务则是有Spring来帮助我们来实现的。

而事务又是我们日常操作过程中最为常用且常用的，我们不知道Spring事务如何给我们操作的，所以建议不要将事务由Spring来进行处理，而是我们手动的来进行管理！！！

编程式事务管理
  • 所谓事务管理，即：按照给定的事务规则，来执行提交或回滚操作。其中：
    • 给定的事务规则：用TransactionDefinition表示
    • 按照…来执行提交或回滚操作：用PlatformTransactionManager来完成
    • TransactionStatus用于表示一个运行着的事务的状态

对于PlatformTransactionManager和TransactionStatus来说，是固定的套路，但是我们最需要关注的是这里的事务规则，也就是TransactionDefinition，在下面会重点关注和介绍。

关于编程式事务的说明以及API介绍

  • 编程式事务管理：通过编写代码的方式实现事务管理

    • 编程式事务管理，因事务管理与业务功能耦合性太强，不方便维护，目前已经基本不用，但是与SpringAOP结合起来使用更佳。

      spring 2.0 就已经提供了 xml配置的声明式事务管理的支持

  • 以下API仅做介绍了解，用于了解Spring事务相关的API，并回顾事务相关的概念

PlatformTransactionManager
  • 是Spring提供的事务管理器接口，它提供了我们常用的操作事务的方法：开启事务、提交事务等
  • 注意：PlatformTransactionManager是接口类型，不同的dao层技术有不同的实现，例如：
    • dao层是jdbcTemplate或Mybatis时，实现类是：DataSourceTransactionManager。而我们最常用的就是mybatis，所以肯定使用的是DataSourceTransactionManager。
    • dao层是Hibernate时，实现类是：HibernateTransactionManager
方法 返回值 说明
getTransaction(TransactionDefinition td) TransactionStatus 开启事务,并得到事务状态
commit(TransactionStatus status) 提交事务
rollback(TransactionStatus status) 回滚事务
TransactionDefinition
  • 事务的定义信息对象，提供了以下常用方法：
方法 参数 返回值 说明
getIsolationLevel() int 获取事务的隔离级别
getPropogationBehavior() int 获取事务的传播行为
getTimeout() int 获取超时时间
isReadOnly() boolean 是否只读的事务
事务的隔离级别：
  • ISOLATION_DEFAULT：默认事务隔离级别
    • MySql默认隔离级别：repeatable read
    • Oracle默认隔离级别：read committed
  • ISOLATION_READ_UNCOMMITTED：读未提交–存在脏读、不可重复读、幻读
  • ISOLATION_READ_COMMITTED：读已提交–存在不可重复读、幻读
  • ISOLATION_REPEATABLE_READ：重复读–存在幻读
  • ISOLATION_SERIALIZABLE：串行化–没有并发问题
事务的传播行为：

用于解决业务方法调用业务方法时，事务的统一性问题的

SpringAOP以及事务管理和优化处理_第4张图片

也就是说service中的methodA方法调用methodB方法的时候，对于methodB来说，叫做传播行为，决定使用怎么样的事务来调用methodB方法。

以下三个，是要当前事务的

  • PROPAGATION_REQUIRED：需要有事务。默认
    • 如果有事务，就使用这个事务
    • 如果没有事务，就创建事务。
  • PROPAGATION_SUPPORTS：支持事务
    • 如果有事务，就使用当前事务，
    • 如果没有事务，就以非事务方式执行（没有事务）
  • PROPAGATION_MANDATORY：强制的
    • 如果有事务，就使用当前事务
    • 如果没有事务，就抛异常

以下三个，是不要当前事务的

  • PROPAGATION_REQUIRES_NEW：新建的
    • 如果有事务，就把事务挂起，再新建事务
    • 如果没有事务，新建事务
  • PROPAGATION_NOT_SUPPORTED：不支持的
    • 如果有事务，就把事务挂起，以非事务方式执行
    • 如果没有事务，就以非事务方式执行
  • PROPAGATION_NEVER：非事务的
    • 如果有事务，就抛异常
    • 如果没有事务，就以非事务方式执行

最后一个，是特殊的

  • PROPAGATION_NESTED：嵌套的
    • 如果有事务，就在事务里再嵌套一个事务执行
    • 如果没有事务，就是类似REQUIRED的操作
事务运行的超时时间：

超时后事务自动回滚

  • 默认值-1，表示没有超时限制
  • 如果有，可以以秒为单位进行设置
是否只读：
  • 如果设置为只读，那么方法只能查询，不能增删改
  • 通常是查询方法设置为只读
TransactionStatus
  • 提供了查询事务具体运行状态的方法，常用方法如下：
方法 返回值 说明
hasSavePoint() boolean 事务是否有回滚点
isCompleted() boolean 事务是否已经完成
isNewTransaction() boolean 是否是新事务
isRollbackOnly() boolean 事务是否是要回滚的状态
小结
  • PlatformTransactionManager接口：
    • 如果dao层用的是Mybatis、JdbcTemplate：用DataSourceTransactionManager
    • 如果dao层用的是Hibernate：用HibernateTransactionManager
  • 事务定义信息：
    • 事务的隔离级别：通常使用默认ISOLATION_DEFAULT
    • 事务的传播行为：通常使用默认PROPAGATION_REQUIRED
    • 事务的超时时间：如果事务执行超时，会回滚。单位是秒。值为-1表示永不超时
    • 事务是否是只读：如果只读，事务里只能执行查询操作，不能增删改
  • 事务状态接口
    • 事务是否有回滚点
    • 事务是否已经完成
    • 是否是新事务
    • 事务是否是要回滚的状态
示例代码一

下面也是来给出例子来进行说明展示：

给出实体类：

public class Account {
    private Integer id;
    private String name;
    private Float money;
    // 省略get/set方法
}

给出业务逻辑代码：

public interface AccountService {
    void transfer(String from, String to, Float money);
}

具体实现类中的代码：

@Service("accountService")
public class AccountServiceImpl implements AccountService {

    // 引入事务操作
    @Autowired
    private AccountDao accountDao;
    
    @Autowired
    private TransactionDefinition txDefinition;
    
    @Autowired
    private PlatformTransactionManager txManager;

    @Override
    public void transfer(String from, String to, Float money) {
        //开启事务，得到事务状态
        TransactionStatus txStatus = txManager.getTransaction(txDefinition);
        try {
            //操作dao
            Account fromAccount = accountDao.findByName(from);
            Account toAccount = accountDao.findByName(to);
            fromAccount.setMoney(fromAccount.getMoney() - money);
            toAccount.setMoney(toAccount.getMoney() + money);
            accountDao.edit(fromAccount);
            accountDao.edit(toAccount);
            //提交事务
            txManager.commit(txStatus);
        } catch (Exception e) {
            //回滚事务
            txManager.rollback(txStatus);
            // 出现异常，进行补偿机制
        }
    }
}

那么给出dao代码：

public interface AccountDao {
    void edit(Account account) throws SQLException;
    Account findByName(String name) throws SQLException;
}

实现类代码：

package com.guang.dao.impl;

import com.guang.dao.AccountDao;
import com.guang.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.sql.SQLException;
import java.util.List;

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void edit(Account account) throws SQLException {
        jdbcTemplate.update("update account set name=?, money=? where id=?", account.getName(), account.getMoney(), account.getId());
    }

    @Override
    public Account findByName(String name) throws SQLException {
        List<Account> accounts = jdbcTemplate.query("select * from account where name = ?", new BeanPropertyRowMapper<>(Account.class), name);
        if (accounts == null || accounts.size() == 0) {
            return null;
        }else{
            return accounts.get(0);
        }
    }
}

然后给出配置文件代码


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.guang"/>

    
    <bean id="txDefinition" class="org.springframework.transaction.support.DefaultTransactionDefinition">
        
        <property name="propagationBehaviorName" value="PROPAGATION_REQUIRED"/>
        
        <property name="isolationLevelName" value="ISOLATION_DEFAULT"/>
        
        <property name="timeout" value="-1"/>
        
        <property name="readOnly" value="false"/>
    bean>
    
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    bean>
    
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    bean>
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <constructor-arg name="dataSource" ref="dataSource"/>
    bean>
beans>

从上面来看业务逻辑操作的话，可以看到代码侵入性太高！很明显不适合来使用。

@Service("accountService")
public class AccountServiceImpl implements AccountService {
    
    @Autowired
    private TransactionDefinition txDefinition;
    @Autowired
    private PlatformTransactionManager txManager;

    @Override
    public void transfer(String from, String to, Float money) {
        //开启事务，得到事务状态
        TransactionStatus txStatus = txManager.getTransaction(txDefinition);
        try {
            // ....
            //提交事务
            txManager.commit(txStatus);
        } catch (Exception e) {
            //回滚事务
            txManager.rollback(txStatus);
            e.printStackTrace();
        }
    }
}

但是从这里来看的话，无非就是多用了PlatformTransactionManager和TransactionDefinition而已。

  • 那么我的想法是将上面的代码抽取起来写成一个通知类型，然后配置PointCut和Advice组成Advisor。然而在我即将要动手去写的时候，在查看DefaultTransactionDefinition类的时候，我发现有继承类TransactionTemplate，我一看这玩意儿不是我们在项目中经常使用的一个类吗？以前也写过，也遇到过，但是在这里遇到的时候，我才恍然大悟。原来我们一直就是这么用的，但是从来没有去想过背后的原理，所以这也是写这篇博客的收获之一！非常幸运。

那么首先来分析一下我原来的思路（即按照切面类的想法）

  • 1、针对读写类型来定义事务规则，这里涉及到四个属性，在DefaultTransactionDefinition中存在：

    • propagationBehavior，默认值是PROPAGATION_REQUIRED，即表示有事务就使用这个事务，没有事务就不用；
    • isolationLevel，默认值是：ISOLATION_DEFAULT，即表示默认使用数据库的事务。如果使用的是MySQL，那么就用MySQL的RR，可重复读级别；
    • timeout：默认值是：TIMEOUT_DEFAULT（-1），表示永不超时，超时时间以秒为单位；
    • readOnly：默认值是：false，表示的是增删改查询使用事务，查询不使用事务；

    之前我想的是定义多个事务规则对象，然后配置多个环绕通知方法，在开启事务的时候，根据不同的事务规则对象来获取得到事务。

  • 2、注入事务管理器，然后传入事务规则定义，获取得到当前的事务状态；

  • 3、利用事务管理器通过状态来进行提交或者是回滚事务；

上面可以通过AOP切面类来进行配置，但是看到了TransactionTemplate之后，我发现根本就不需要使用到切面类就可以来进行操作。

那么首先来看下TransactionTemplate类的继承体系：

SpringAOP以及事务管理和优化处理_第5张图片

分析一下继承体系：

  • 1、继承了DefaultTransactionDefinition类，所以可以用来定义事务规则信息对象；

  • 2、实现了InitializingBean接口，那么肯定是要在初始化方法来做操作；

  • 3、实现了TransactionOperations接口，从接口名称中可以知道这里代表的是事务；

而在TransactionTemplate类中，只有一个属性PlatformTransactionManager，而这是又是我们所需要的事务管理器。

而在InitializingBean接口的初始化方法中做了校验，如下所示：

	public void afterPropertiesSet() {
		if (this.transactionManager == null) {
			throw new IllegalArgumentException("Property 'transactionManager' is required");
		}
	}

因为TransactionTemplate中存在无参方法，没有注入transactionManager对象，说明我们需要手动注入当前容器中的transactionManager对象。那么配置TransactionTemplate的时候可以配置如下所示：

<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
    <property name="transactionManager" ref="transactionManager" />
    <!--针对于不同的类型来配置传播行为、隔离级别、超时时间和是否只读，因为可以继承父类中的属性-->
    <!--还可以配置传播行为、隔离级别、超时时间和是否只读，因为可以继承父类中的属性-->
</bean>

如下所示，配置多个事务定义规则：

<bean id="transactionTemplate1" class="org.springframework.transaction.support.TransactionTemplate">
    <property name="transactionManager" ref="transactionManager" />
    <!--事务传播特性-->
    <property name="propagationBehaviorName" value="PROPAGATION_REQUIRED"/>
    <!--事务隔离级别-->
    <property name="isolationLevelName" value="ISOLATION_DEFAULT"/>
    <!--事务超时时间-->
    <property name="timeout" value="-1"/>
    <!--事务是否只读-->
    <property name="readOnly" value="false"/>
</bean>
    
    
<bean id="transactionTemplat2" class="org.springframework.transaction.support.TransactionTemplate">
    <property name="transactionManager" ref="transactionManager" />
    <!--事务传播特性-->
    <property name="propagationBehaviorName" value="PROPAGATION_REQUIRED"/>
    <!--事务隔离级别-->
    <property name="isolationLevelName" value="ISOLATION_DEFAULT"/>
    <!--事务超时时间-->
    <property name="timeout" value="3"/>
    <!--事务是否只读-->
    <property name="readOnly" value="false"/>
</bean>    
    
<bean id="transactionTemplat3" class="org.springframework.transaction.support.TransactionTemplate">
    <property name="transactionManager" ref="transactionManager" />
    <!--事务传播特性-->
    <property name="propagationBehaviorName" value="PROPAGATION_REQUIRED"/>
    <!--事务隔离级别-->
    <property name="isolationLevelName" value="ISOLATION_DEFAULT"/>
    <!--事务超时时间-->
    <property name="timeout" value="3"/>
    <!--事务是否只读-->
    <property name="readOnly" value="true"/>
</bean>

那么只需要在使用的时候，通过以下方式注入即可：

@Autowired
@Qulifier("transactionTemplat1")
private TransactionTemplate transactionTemplate
    
@Autowired
@Qulifier("transactionTemplat2")
private TransactionTemplate transactionTemplate
    
@Autowired
@Qulifier("transactionTemplat3")
private TransactionTemplate transactionTemplate

通过这种方式来进行注入即可，也是比较方便的。

那么上面说完事务规则定义这块，这块应该有个疑问：在TransactionTemplate从哪里根据事务管理器获取得到事务状态的代码呢？

类似如下的代码：

@Service("accountService")
public class AccountServiceImpl implements AccountService {
    
    @Autowired
    private TransactionDefinition txDefinition;
    @Autowired
    private PlatformTransactionManager txManager;

    @Override
    public void transfer(String from, String to, Float money) {
        //开启事务，得到事务状态
        TransactionStatus txStatus = txManager.getTransaction(txDefinition);
        try {
            // ....
            //提交事务
            txManager.commit(txStatus);
        } catch (Exception e) {
            //回滚事务
            txManager.rollback(txStatus);
            e.printStackTrace();
        }
    }
}

来从TransactionTemplate中找，发现就提供了一个方法：execute方法，那么重点就关注一下execute方法即可。

这个方法也是非常的简单，重点是这里的TransactionCallback接口，提前看下：

public interface TransactionCallback<T> {
	T doInTransaction(TransactionStatus status);
}

接口中只有一个抽象方法，又被称之为函数式接口。不懂的话接着向下看

SpringAOP以及事务管理和优化处理_第6张图片

这里的方法也是非常简单呐，相当于是已经帮助我们做好了。

给出一个使用代码示例：

这里给的是没有返回值的，所以这里给的是Void类型。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;
 
@Service
public class TransactionalService {
 
    @Autowired
    private TransactionTemplate transactionTemplate;
 
    public void performTransactionalOperation() {
        // 不建议使用下面两行代码！因为如果忘记了设置会默认值，那么后面再次使用的时候默认使用的九种方式
        /**nsactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        transactionTemplate.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);**/
 
        transactionTemplate.execute(new TransactionCallback<Void>() {
            public Void doInTransaction(TransactionStatus status) {
                // 在这里执行事务操作
                // 可以进行数据库操作、调用其他需要事务支持的方法等
 
                return null;
            }
        });
    }
}

再给出一个有值的代码且可以自己来处理事务状态。不利用事务管理中的回滚方法而已！

public Object getObject(String str) {
        /*
         *  执行带有返回值的事务管理
         */
        transactionTemplate.execute(new TransactionCallback<Object>() {
            @Override
            public Object doInTransaction(TransactionStatus transactionStatus) {
                try {
                      ...
                    //.......   业务代码
                    return new Object();
                    // 注意：这里没有提交代码的逻辑
                } catch (Exception e) {
                    // 回滚，这里并不是利用事务管理器进行提交的，这里只是设置了一个标记而已
                    // 在事务管理进行事务提交的时候会来检查这里的状态而已
                    transactionStatus.setRollbackOnly();
                    return null;
                }
            }
        });
}
 
  
示例代码二
 
  
在上面的分析代码中，给出示例代码二：
 
  
首先给出配置xml文件：
 
  
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.guang.dao"/>
    <context:component-scan base-package="com.guang.service.impl1."/>

    <!--事务的定义-->
    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <!--配置事务管理器-->
        <property name="transactionManager" ref="txManager"/>
        <!--事务传播特性！如果调用其他方法的时候，直接使用当前方法中的事务-->
        <property name="propagationBehaviorName" value="PROPAGATION_REQUIRED"/>
        <!--事务隔离级别，使用数据库的操作-->
        <property name="isolationLevelName" value="ISOLATION_DEFAULT"/>
        <!--事务超时时间-->
        <property name="timeout" value="-1"/>
        <!--事务是否只读！因为是有更新操作，所以这里进行修改操作-->
        <property name="readOnly" value="false"/>
    </bean>
    <!--定义事务管理器-->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--定义连接池-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!--定义JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <constructor-arg name="dataSource" ref="dataSource"/>
    </bean>
</beans>

 
  
然后给出代码：
 
  
package com.guang.service.impl1;

import com.guang.dao.AccountDao;
import com.guang.domain.Account;
import com.guang.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;


@Service("accountService")
public class AccountServiceImpl1 implements AccountService {

    @Autowired
    private AccountDao accountDao;

    @Autowired
    private TransactionTemplate transactionTemplate;

    @Override
    public void transfer(String from, String to, Float money) {

        transactionTemplate.execute((status)-> {
                try {
                    // 来做事务操作
                    Account fromAccount = accountDao.findByName(from);
                    Account toAccount = accountDao.findByName(to);
                    fromAccount.setMoney(fromAccount.getMoney() - money);
                    toAccount.setMoney(toAccount.getMoney() + money);
                    accountDao.edit(fromAccount);
                    int i = 1 / 0;
                    accountDao.edit(toAccount);
                } catch ( Exception exception) {
                    System.out.println("执行SQL阶段出现异常！不能够进行提交");
                    status.setRollbackOnly();
                }
                return null;
            });
        System.out.println("使用事务管理器来执行代码完成");
    }
}

 
  
然后将代码放置到仓库中去
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(spring,java,spring)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                                
  • apache 安装linux windows
                                    墙头上一根草
apacheinuxwindows
                                    
    linux安装Apache 有两种方式一种是手动安装通过二进制的文件进行安装，另外一种就是通过yum 安装，此中安装方式，需要物理机联网。以下分别介绍两种的安装方式 
  
  
通过二进制文件安装Apache需要的软件有apr,apr-util,pcre 
 1，安装 apr        下载地址：htt
    
                                
    • 
                                
  • fill_parent、wrap_content和match_parent的区别
                                    Cb123456
match_parentfill_parent
                                    
    fill_parent、wrap_content和match_parent的区别: 
  
1）fill_parent 
  设置一个构件的布局为fill_parent将强制性地使构件扩展，以填充布局单元内尽可能多的空间。这跟Windows控件的dockstyle属性大体一致。设置一个顶部布局或控件为fill_parent将强制性让它布满整个屏幕。 
2） wrap_conte
    
                                
    • 
                                
  • 网页自适应设计
                                    天子之骄
htmlcss响应式设计页面自适应
                                    
    网页自适应设计 
       网页对浏览器窗口的自适应支持变得越来越重要了。自适应响应设计更是异常火爆。再加上移动端的崛起，更是如日中天。以前为了适应不同屏幕分布率和浏览器窗口的扩大和缩小，需要设计几套css样式，用js脚本判断窗口大小，选择加载。结构臃肿，加载负担较大。现笔者经过一定时间的学习，有所心得，故分享于此，加强交流，共同进步。同时希望对大家有所
    
                                
    • 
                                
  • [sql server] 分组取最大最小常用sql
                                    一炮送你回车库
SQL Server
                                    
    --分组取最大最小常用sql--测试环境if OBJECT_ID('tb') is not null drop table tb;gocreate table tb( col1 int, col2 int, Fcount int)insert into tbselect 11,20,1 union allselect 11,22,1 union allselect 1
    
                                
    • 
                                
  • ImageIO写图片输出到硬盘
                                    3213213333332132
javaimage
                                    
    package awt; 
 
import java.awt.Color; 
import java.awt.Font; 
import java.awt.Graphics; 
import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.IOException; 
 
import javax.imagei
    
                                
    • 
                                
  • 自己的String动态数组
                                    宝剑锋梅花香
java动态数组数组
                                    
    数组还是好说，学过一两门编程语言的就知道，需要注意的是数组声明时需要把大小给它定下来，比如声明一个字符串类型的数组：String str[]=new String[10];    但是问题就来了，每次都是大小确定的数组，我需要数组大小不固定随时变化怎么办呢？  动态数组就这样应运而生，龙哥给我们讲的是自己用代码写动态数组，并非用的ArrayList 看看字符
    
                                
    • 
                                
  • pinyin4j工具类
                                    darkranger
.net
                                    
    pinyin4j工具类Java工具类 2010-04-24 00:47:00 阅读69 评论0 字号：大中小 
引入pinyin4j-2.5.0.jar包: 
pinyin4j是一个功能强悍的汉语拼音工具包，主要是从汉语获取各种格式和需求的拼音，功能强悍，下面看看如何使用pinyin4j。 
 
本人以前用AscII编码提取工具，效果不理想，现在用pinyin4j简单实现了一个。功能还不是很完美，
    
                                
    • 
                                
  • StarUML学习笔记----基本概念
                                    aijuans
UML建模
                                    
    介绍StarUML的基本概念，这些都是有效运用StarUML?所需要的。包括对模型、视图、图、项目、单元、方法、框架、模型块及其差异以及UML轮廓。 
        模型、视与图（Model, View and Diagram） 
       &
    
                                
    • 
                                
  • Activiti最终总结
                                    avords
Activiti id 工作流
                                    
    1、流程定义ID：ProcessDefinitionId，当定义一个流程就会产生。 
2、流程实例ID：ProcessInstanceId，当开始一个具体的流程时就会产生，也就是不同的流程实例ID可能有相同的流程定义ID。 
3、TaskId，每一个userTask都会有一个Id这个是存在于流程实例上的。 
4、TaskDefinitionKey和（ActivityImpl activityId 
    
                                
    • 
                                
  • 从省市区多重级联想到的，react和jquery的差别
                                    bee1314
jqueryUIreact
                                    
    在我们的前端项目里经常会用到级联的select，比如省市区这样。通常这种级联大多是动态的。比如先加载了省，点击省加载市，点击市加载区。然后数据通常ajax返回。如果没有数据则说明到了叶子节点。       针对这种场景，如果我们使用jquery来实现，要考虑很多的问题，数据部分，以及大量的dom操作。比如这个页面上显示了某个区，这时候我切换省，要把市重新初始化数据，然后区域的部分要从页面
    
                                
    • 
                                
  • Eclipse快捷键大全
                                    bijian1013
javaeclipse快捷键
                                    
    Ctrl+1 快速修复(最经典的快捷键,就不用多说了)Ctrl+D: 删除当前行 Ctrl+Alt+↓ 复制当前行到下一行(复制增加)Ctrl+Alt+↑ 复制当前行到上一行(复制增加)Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)Alt+↑ 当前行和上面一行交互位置(同上)Alt+← 前一个编辑的页面Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)Alt+En
    
                                
    • 
                                
  • js 笔记 函数
                                    征客丶
JavaScript
                                    
    一、函数的使用 
1.1、定义函数变量 
var vName = funcation(params){ 
} 
 
1.2、函数的调用 
函数变量的调用：      vName(params); 
函数定义时自发调用：(function(params){})(params); 
 
1.3、函数中变量赋值 
var a = 'a'; 
var ff
    
                                
    • 
                                
  • 【Scala四】分析Spark源代码总结的Scala语法二
                                    bit1129
scala
                                    
    1. Some操作 
  
在下面的代码中，使用了Some操作：if (self.partitioner == Some(partitioner))，那么Some(partitioner)表示什么含义？首先partitioner是方法combineByKey传入的变量， 
Some的文档说明： 
  
/** Class `Some[A]` represents existin
    
                                
    • 
                                
  • java 匿名内部类
                                    BlueSkator
java匿名内部类
                                    
    组合优先于继承 
Java的匿名类，就是提供了一个快捷方便的手段，令继承关系可以方便地变成组合关系 
继承只有一个时候才能用，当你要求子类的实例可以替代父类实例的位置时才可以用继承。 
  
在Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。 
内部类不是很好理解，但说白了其实也就是一个类中还包含着另外一个类如同一个人是由大脑、肢体、器官等身体结果组成，而内部类相
    
                                
    • 
                                
  • 盗版win装在MAC有害发热，苹果的东西不值得买，win应该不用
                                    ljy325
游戏applewindowsXPOS
                                    
    Mac mini 型号: MC270CH-A RMB:5,688 
  
Apple 对windows的产品支持不好,有以下问题: 
  
1.装完了xp,发现机身很热虽然没有运行任何程序！貌似显卡跑游戏发热一样，按照那样的发热量,那部机子损耗很大,使用寿命受到严重的影响! 
  
2.反观安装了Mac os的展示机，发热量很小，运行了1天温度也没有那么高 
&nbs
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-生成器模式-Builder
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/**
 * 生成器模式的意图在于将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示（GoF）
 * 个人理解：
 * 构建一个复杂的对象，对于创建者（Builder）来说，一是要有数据来源(rawData)，二是要返回构
    
                                
    • 
                                
  • JIRA与SVN插件安装
                                    chenyu19891124
SVNjira
                                    
    JIRA安装好后提交代码并要显示在JIRA上，这得需要用SVN的插件才能看见开发人员提交的代码。 
1.下载svn与jira插件安装包，解压后在安装包(atlassian-jira-subversion-plugin-0.10.1) 
2.解压出来的包里下的lib文件夹下的jar拷贝到(C:\Program Files\Atlassian\JIRA 4.3.4\atlassian-jira\WEB
    
                                
    • 
                                
  • 常用数学思想方法
                                    comsci
工作
                                    
      对于搞工程和技术的朋友来讲，在工作中常常遇到一些实际问题，而采用常规的思维方式无法很好的解决这些问题，那么这个时候我们就需要用数学语言和数学工具，而使用数学工具的前提却是用数学思想的方法来描述问题。。下面转帖几种常用的数学思想方法，仅供学习和参考 
 
 
 
  函数思想 
　　把某一数学问题用函数表示出来，并且利用函数探究这个问题的一般规律。这是最基本、最常用的数学方法
    
                                
    • 
                                
  • pl/sql集合类型
                                    daizj
oracle集合typepl/sql
                                    
    --集合类型 
/* 
  单行单列的数据，使用标量变量 
  单行多列数据，使用记录 
  单列多行数据，使用集合（。。。） 
  *集合：类似于数组也就是。pl/sql集合类型包括索引表（pl/sql table）、嵌套表（Nested Table）、变长数组（VARRAY）等 
*/ 
/* 
    --集合方法 
&n
    
                                
    • 
                                
  • [Ofbiz]ofbiz初用
                                    dinguangx
电商ofbiz
                                    
    从github下载最新的ofbiz（截止2015-7-13），从源码进行ofbiz的试用 
1. 加载测试库 
ofbiz内置derby，通过下面的命令初始化测试库 
./ant load-demo (与load-seed有一些区别) 
  
2. 启动内置tomcat 
./ant start 
或 
./startofbiz.sh 
或 
java -jar ofbiz.jar 
&
    
                                
    • 
                                
  • 结构体中最后一个元素是长度为0的数组
                                    dcj3sjt126com
cgcc
                                    
    在Linux源代码中，有很多的结构体最后都定义了一个元素个数为0个的数组，如/usr/include/linux/if_pppox.h中有这样一个结构体： struct pppoe_tag {     __u16 tag_type;     __u16 tag_len;   &n
    
                                
    • 
                                
  • Linux cp 实现强行覆盖
                                    dcj3sjt126com
linux
                                    
    发现在Fedora 10 /ubutun 里面用cp -fr src dest，即使加了-f也是不能强行覆盖的，这时怎么回事的呢？一两个文件还好说，就输几个yes吧，但是要是n多文件怎么办，那还不输死人呢？下面提供三种解决办法。 方法一 
 
 我们输入alias命令，看看系统给cp起了一个什么别名。 
  
  [root@localhost ~]# aliasalias cp=’cp -i’a
    
                                
    • 
                                
  • Memcached(一)、HelloWorld
                                    frank1234
memcached
                                    
    一、简介 
高性能的架构离不开缓存，分布式缓存中的佼佼者当属memcached，它通过客户端将不同的key hash到不同的memcached服务器中，而获取的时候也到相同的服务器中获取，由于不需要做集群同步，也就省去了集群间同步的开销和延迟，所以它相对于ehcache等缓存来说能更好的支持分布式应用，具有更强的横向伸缩能力。 
二、客户端 
选择一个memcached客户端，我这里用的是memc
    
                                
    • 
                                
  • Search in Rotated Sorted Array II
                                    hcx2013
search
                                    
    Follow up for "Search in Rotated Sorted Array":What if duplicates are allowed? 
Would this affect the run-time complexity? How and why? 
Write a function to determine if a given ta
    
                                
    • 
                                
  • Spring4新特性——更好的Java泛型操作API
                                    jinnianshilongnian
spring4generic type
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • CentOS安装JDK
                                    liuxingguome
centos
                                    
    1、行卸载原来的： 
[root@localhost opt]# rpm -qa | grep java 
tzdata-java-2014g-1.el6.noarch 
java-1.7.0-openjdk-1.7.0.65-2.5.1.2.el6_5.x86_64 
java-1.6.0-openjdk-1.6.0.0-11.1.13.4.el6.x86_64 
[root@localhost
    
                                
    • 
                                
  • 二分搜索专题2-在有序二维数组中搜索一个元素
                                    OpenMind
二维数组算法二分搜索
                                    
    1,设二维数组p的每行每列都按照下标递增的顺序递增。 
用数学语言描述如下：p满足 
(1),对任意的x1，x2，y，如果x1<x2,则p(x1,y)<p(x2,y); 
(2),对任意的x，y1,y2, 如果y1<y2,则p(x,y1)<p(x,y2); 
2,问题： 
给定满足1的数组p和一个整数k，求是否存在x0,y0使得p(x0,y0)=k? 
3,算法分析： 
(
    
                                
    • 
                                
  • java 随机数 Math与Random
                                    SaraWon
javaMathRandom
                                    
    今天需要在程序中产生随机数，知道有两种方法可以使用，但是使用Math和Random的区别还不是特别清楚，看到一篇文章是关于的，觉得写的还挺不错的，原文地址是 
http://www.oschina.net/question/157182_45274?sort=default&p=1#answers 
 
产生1到10之间的随机数的两种实现方式： 
 

//Math
Math.roun
    
                                
    • 
                                
  • oracle创建表空间
                                    tugn
oracle
                                    
    create temporary tablespace TXSJ_TEMP   
tempfile 'E:\Oracle\oradata\TXSJ_TEMP.dbf'   
size 32m   
autoextend on   
next 32m maxsize 2048m   
extent m
    
                                
    • 
                                
  • 使用Java8实现自己的个性化搜索引擎
                                    yangshangchuan
javasuperword搜索引擎java8全文检索
                                    
    需要对249本软件著作实现句子级别全文检索，这些著作均为PDF文件，不使用现有的框架如lucene，自己实现的方法如下： 
1、从PDF文件中提取文本，这里的重点是如何最大可能地还原文本。提取之后的文本，一个句子一行保存为文本文件。 
2、将所有文本文件合并为一个单一的文本文件，这样，每一个句子就有一个唯一行号。 
3、对每一行文本进行分词，建立倒排表，倒排表的格式为：词=包含该词的总行数N=行号
    
                                
    •