毛子果
毛子果

2018-05-19

spring源码分析（五）

目录

五、源码分析
--5.6、Spring AOP 设计原理及具体实践
----5.6.1、SpringAOP 应用示例
------AOP 的相关概念
------通知（Advice）类型
------使用 SpringAOP 两种方式
--------表达式中使用”execution“
--------访问当前的连接点
--------通知参数
----5.6.2、SpringAOP 设计原理及源码分析

五、源码分析

5.6、Spring AOP 设计原理及具体实践
5.6.1、SpringAOP 应用示例

AOP 是 OOP 的延续，是 AspectOrientedProgramming 的缩写，意思是面向切面编程。可以通过预编译方式和运行期动态代 理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。 AOP 设计模式孜孜不倦追求的是调用者和被调用者之 间的解耦，AOP 可以说也是这种目标的一种实现。

我们现在做的一些非业务，如：日志、事务、安全等都会写在业务代码中(也即是说，这些非业务类横切于业务类)，但这些 代码往往是重复，复制——粘贴式的代码会给程序的维护带来不便，AOP 就实现了把这些业务需求与系统需求分开来做。这 种解决的方式也称代理机制。

AOP 的相关概念

  • 切面（Aspect）：官方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”。“切面”在 ApplicationContext 中来配置。

  • 连接点（Joinpoint）：程序执行过程中的某一行为，例如，MemberService.get 的调用或者 MemberService.delete 抛出异常等行为。  通知（Advice） ：“切面”对于某个“连接点”所产生的动作。其中，一个“切面”可以包含多个“Advice”。

  • 切入点（Pointcut） ：匹配连接点的断言，在 AOP 中通知和一个切入点表达式关联。切面中的所有通知所关注的连 接点，都由切入点表达式来决定。

  • 目标对象（TargetObject） ：被一个或者多个切面所通知的对象。例如，AServcieImpl 和 BServiceImpl，当然在实 际运行时，SpringAOP 采用代理实现，实际 AOP 操作的是 TargetObject 的代理对象。

  • AOP 代理（AOPProxy）：在 SpringAOP 中有两种代理方式， JDK 动态代理和 CGLIB 代理。默认情况下， TargetObject 实现了接口时，则采用 JDK 动态代理，例如，AServiceImpl；反之，采用 CGLIB 代理，例如，BServiceImpl。强制 使用 CGLIB 代理需要将 的 proxy-target-class 属性设为 true。

通知（Advice）类型：

  • 前置通知（Beforeadvice）：在某连接点（JoinPoint）之前执行的通知，但这个通知不能阻止连接点前的执行。 ApplicationContext 中在里面使用元素进行声明。例如，TestAspect 中的 doBefore 方法。

  • 后置通知（Afteradvice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。ApplicationContext 中在里面使用元素进行声明。例如，ServiceAspect 中的 returnAfter 方法，所以 Teser 中调用 UserService.delete 抛出异常时，returnAfter 方法仍然执行。

  • 返回后通知（Afterreturnadvice）：在某连接点正常完成后执行的通知，不包括抛出异常的情况。ApplicationContext 中在里面使用元素进行声明。

  • 环绕通知（Aroundadvice）：包围一个连接点的通知，类似 Web 中 Servlet 规范中的 Filter 的 doFilter 方法。可以在 方法的调用前后完成自定义的行为，也可以选择不执行。ApplicationContext 中在里面使用 元素进行声明。例如，ServiceAspect 中的 around 方法。

  • 抛出异常后通知（Afterthrowingadvice）：在方法抛出异常退出时执行的通知。ApplicationContext 中在 里面使用元素进行声明。例如，ServiceAspect 中的 returnThrow 方法。

注：可以将多个通知应用到一个目标对象上，即可以将多个切面织入到同一目标对象。

使用 SpringAOP 可以基于两种方式:

  • 一种是比较方便和强大的注解方式
  • 另一种则是中规中矩的 xml 配置方式。

注解，使用注解配置 SpringAOP 总体分为两步:

第一步是在 xml 文件中声明激活自动扫描组件功能，同时激活自动代 理功能（来测试 AOP 的注解功能）：

第二步是为 Aspect 切面类添加注解：

//声明这是一个组件
@Component
//声明这是一个切面Bean
@Aspect
public class AnnotaionAspect {
    private final static Logger log = Logger.getLogger(AnnotaionAspect.class);
    //配置切入点,该方法无方法体,主要为方便同类中其他方法使用此处配置的切入点
    @Pointcut("execution(* com.gupaoedu.aop.service..*(..))")
    public void aspect(){ }
    /*
    * 配置前置通知,使用在方法aspect()上注册的切入点
    * 同时接受JoinPoint切入点对象,可以没有该参数
    */
    @Before("aspect()")
    public void before(JoinPoint joinPoint){
        log.info("before " + joinPoint);
    }
    //配置后置通知,使用在方法aspect()上注册的切入点
    @After("aspect()")
    public void after(JoinPoint joinPoint){
        log.info("after " + joinPoint);
    }
    //配置环绕通知,使用在方法aspect()上注册的切入点
    @Around("aspect()")
    public void around(JoinPoint joinPoint){
        long start = System.currentTimeMillis();
        try {
            ((ProceedingJoinPoint) joinPoint).proceed();
            long end = System.currentTimeMillis();
            log.info("around " + joinPoint + "\tUse time : " + (end - start) + " ms!");
        } catch (Throwable e) {
            long end = System.currentTimeMillis();
            log.info("around " + joinPoint + "\tUse time : " + (end - start) + " ms with exception : " + e.getMessage());
        }
    }
    //配置后置返回通知,使用在方法aspect()上注册的切入点
    @AfterReturning("aspect()")
    public void afterReturn(JoinPoint joinPoint){
        log.info("afterReturn " + joinPoint);
    }
    //配置抛出异常后通知,使用在方法aspect()上注册的切入点
    @AfterThrowing(pointcut="aspect()", throwing="ex")
    public void afterThrow(JoinPoint joinPoint, Exception ex){
        log.info("afterThrow " + joinPoint + "\t" + ex.getMessage());
    }
}

测试代码

@ContextConfiguration(locations = {"classpath*:application-context.xml"})
@RunWith(SpringJUnit4ClassRunner.class)
public class AnnotationTester {
    @Autowired MemberService annotationService;
    @Autowired ApplicationContext app;
    @Test
    // @Ignore
    public void test(){
        System.out.println("=====这是一条华丽的分割线======");
        AnnotaionAspect aspect = app.getBean(AnnotaionAspect.class);
        System.out.println(aspect);
        annotationService.save(new Member());
        System.out.println("=====这是一条华丽的分割线======");
        try {
            annotationService.delete(1L);
        } catch (Exception e) {
            //e.printStackTrace();
        }
    }
}

控制台输出如下：

=====这是一条华丽的分割线======
com.gupaoedu.aop.aspect.AnnotaionAspect@6ef714a0
[INFO ] [13:04:46] com.gupaoedu.aop.aspect.AnnotaionAspect - before execution(void
com.gupaoedu.aop.service.MemberService.save(Member))
[INFO ] [13:04:46] com.gupaoedu.aop.aspect.ArgsAspect - beforeArgUser execution(void
com.gupaoedu.aop.service.MemberService.save(Member))
[INFO ] [13:04:46] com.gupaoedu.aop.aspect.AnnotaionAspect - save member method . . . [INFO ] [13:04:46] com.gupaoedu.aop.aspect.AnnotaionAspect - around execution(void
com.gupaoedu.aop.service.MemberService.save(Member)) Use time : 38 ms!
[INFO ] [13:04:46] com.gupaoedu.aop.aspect.AnnotaionAspect - after execution(void
com.gupaoedu.aop.service.MemberService.save(Member))
[INFO ] [13:04:46] com.gupaoedu.aop.aspect.AnnotaionAspect - afterReturn execution(void
com.gupaoedu.aop.service.MemberService.save(Member)) =====这是一条华丽的分割线======
[INFO ] [13:04:46] com.gupaoedu.aop.aspect.AnnotaionAspect - before execution(boolean
com.gupaoedu.aop.service.MemberService.delete(long))
[INFO ] [13:04:46] com.gupaoedu.aop.aspect.ArgsAspect - beforeArgId execution(boolean
com.gupaoedu.aop.service.MemberService.delete(long)) ID:1
[INFO ] [13:04:46] com.gupaoedu.aop.aspect.AnnotaionAspect - delete method . . . [INFO ] [13:04:46] com.gupaoedu.aop.aspect.AnnotaionAspect - around execution(boolean
com.gupaoedu.aop.service.MemberService.delete(long)) Use time : 3 ms with exception : spring aop
ThrowAdvice演示
[INFO ] [13:04:46] com.gupaoedu.aop.aspect.AnnotaionAspect - after execution(boolean
com.gupaoedu.aop.service.MemberService.delete(long))
[INFO ] [13:04:46] com.gupaoedu.aop.aspect.AnnotaionAspect - afterReturn execution(boolean
com.gupaoedu.aop.service.MemberService.delete(long))

可以看到，正如我们预期的那样，虽然我们并没有对 MemberService 类包括其调用方式做任何改变，但是 Spring 仍然拦截到了其中方法的调用，或许这正是 AOP 的魔力所在。

再简单说一下 xml 配置方式，其实也一样简单：

个人觉得不如注解灵活和强大，你可以不同意这个观点，但是不知道如下的代码会不会让你的想法有所改善：

//配置切入点,该方法无方法体,主要为方便同类中其他方法使用此处配置的切入点
@Pointcut("execution(* com.gupaoedu.aop.service..*(..))")
public void aspect(){ }

//配置前置通知,拦截返回值为cn.ysh.studio.spring.mvc.bean.User的方法
@Before("execution(com.gupaoedu.model.Member com.gupaoedu.aop.service..*(..))")
public void beforeReturnUser(JoinPoint joinPoint){
    log.info("beforeReturnUser " + joinPoint);
}

//配置前置通知,拦截参数为cn.ysh.studio.spring.mvc.bean.User的方法
@Before("execution(* com.gupaoedu.aop.service..*(com.gupaoedu.model.Member))")
public void beforeArgUser(JoinPoint joinPoint){
    log.info("beforeArgUser " + joinPoint);
}

//配置前置通知,拦截含有long类型参数的方法,并将参数值注入到当前方法的形参id中
@Before("aspect()&&args(id)")
public void beforeArgId(JoinPoint joinPoint, long id){
    log.info("beforeArgId " + joinPoint + "\tID:" + id);
}

以下是 MemberService 的代码：

@Service
public class MemberService {
    private final static Logger log = Logger.getLogger(AnnotaionAspect.class);
    public Member get(long id){
        log.info("getMemberById method . . .");
        return new Member();
    }
    public Member get(){
        log.info("getMember method . . .");
        return new Member();
    }
    public void save(Member member){
        log.info("save member method . . .");
    }
    public boolean delete(long id) throws Exception{
        log.info("delete method . . .");
        throw new Exception("spring aop ThrowAdvice演示");
    }
}

应该说学习 Spring AOP 有两个难点，第一点在于理解 AOP 的理念和相关概念，第二点在于灵活掌握和使用切入点表达式。

概念的理解通常不在一朝一夕，慢慢浸泡的时间长了，自然就明白了，下面我们简单地介绍一下切入点表达式的配置规则吧。

通常情况下，表达式中使用”execution“就可以满足大部分的要求。表达式格式如下：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?
  • modifiers-pattern：方法的操作权限
  • ret-type-pattern：返回值
  • declaring-type-pattern：方法所在的包
  • name-pattern：方法名
  • parm-pattern：参数名
  • throws-pattern：异常

其中，除 ret-type-pattern 和 name-pattern 之外，其他都是可选的。上例中，execution(com.spring.service..*(..))表示 com.spring.service 包下，返回值为任意类型；方法名任意；参数不作限制的所有方法。

通知参数

可以通过 args 来绑定参数，这样就可以在通知（Advice）中访问具体参数了。例如，配置如下：

上面的代码 args(msg,..)是指将切入点方法上的第一个 String 类型参数添加到参数名为 msg 的通知的入参上，这样就可以直接 使用该参数啦。

访问当前的连接点

在上面的 Aspect 切面 Bean 中已经看到了，每个通知方法第一个参数都是 JoinPoint。其实，在 Spring 中，任何通知（Advice） 方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint 类型用以接受当前连接点对象。JoinPoint 接口提供了一系列有用 的方法， 比如 getArgs() （返回方法参数）、getThis() （返回代理对象）、getTarget() （返回目标）、getSignature() （返回 正在被通知的方法相关信息）和 toString() （打印出正在被通知的方法的有用信息）。

5.6.2、SpringAOP 设计原理及源码分析

开始之前先上图，看看 Spring 中主要的 AOP 组件


2018-05-19_第1张图片
AOP组件.PNG

Spring 提供了两种方式来生成代理对象: JDKProxy 和 Cglib，具体使用哪种方式生成由 AopProxyFactory 根据 AdvisedSupport 对象的配置来决定。默认的策略是如果目标类是接口，则使用 JDK 动态代理技术，否则使用 Cglib 来生成代 理。下面我们来研究一下 Spring 如何使用 JDK 来生成代理对象，具体的生成代码放在 JdkDynamicAopProxy 这个类中，直接 上相关代码：

/**
* 
    
* 
  1. 获取代理类要实现的接口,除了 Advised 对象中配置的,还会加上 SpringProxy, Advised(opaque=false)
* 
  2. 检查上面得到的接口中有没有定义 equals 或者 hashcode 的接口
* 
  3. 调用 Proxy.newProxyInstance 创建代理对象
* 

*/
public Object getProxy(ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating JDK dynamic proxy: target source is " +
        this.advised.getTargetSource());
    }
    Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

那这个其实很明了，注释上我也已经写清楚了，不再赘述。

下面的问题是，代理对象生成了，那切面是如何织入的？

我们知道 InvocationHandler 是 JDK 动态代理的核心，生成的代理对象的方法调用都会委托到 InvocationHandler.invoke() 方法。而通过 JdkDynamicAopProxy 的签名我们可以看到这个类其实也实现了 InvocationHandler，下面我们就通过分析这个 类中实现的 invoke()方法来具体看下 Spring AOP 是如何织入切面的。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    MethodInvocation invocation;
    Object oldProxy = null;
    boolean setProxyContext = false;
    
    TargetSource targetSource = this.advised.targetSource;
    Class targetClass = null;
    Object target = null;
    
    try {
        //eqauls()方法，具目标对象未实现此方法
        if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
            // The target does not implement the equals(Object) method itself.
            return equals(args[0]);
        }
        //hashCode()方法，具目标对象未实现此方法
        if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
            // The target does not implement the hashCode() method itself.
            return hashCode();
        }
        //Advised 接口或者其父接口中定义的方法,直接反射调用,不应用通知
        if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
            method.getDeclaringClass().isAssignableFrom(Advised.class)) {
            // Service invocations on ProxyConfig with the proxy config...
            return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
        }
        Object retVal;
        if (this.advised.exposeProxy) {
            // Make invocation available if necessary.
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }
        // May be null. Get as late as possible to minimize the time we "own" the target,
        // in case it comes from a pool.
        //获得目标对象的类
        target = targetSource.getTarget();
        if (target != null) {
            targetClass = target.getClass();
        }
        // Get the interception chain for this method.
        //获取可以应用到此方法上的 Interceptor 列表
        List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method,
        targetClass);
        
        // Check whether we have any advice. If we don t, we can fallback on direct
        // reflective invocation of the target, and avoid creating a MethodInvocation.
        //如果没有可以应用到此方法的通知(Interceptor)，此直接反射调用 method.invoke(target, args)
        
        if (chain.isEmpty()) {
            // We can skip creating a MethodInvocation: just invoke the target directly
            // Note that the final invoker must be an InvokerInterceptor so we know it does
            // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
            retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
        }else {
            // We need to create a method invocation...
            //创建 MethodInvocation
            invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass,
            chain);
            // Proceed to the joinpoint through the interceptor chain.
            retVal = invocation.proceed();
        }
        // Massage return value if necessary.
        Class returnType = method.getReturnType();
        if (retVal != null && retVal == target && returnType.isInstance(proxy) &&
        !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
            // Special case: it returned "this" and the return type of the method
            // is type-compatible. Note that we can t help if the target sets
            // a reference to itself in another returned object.
            retVal = proxy;
        } else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
            throw new AopInvocationException("Null return value from advice does not match
            primitive return type for: " + method);
        }
        return retVal;
    }finally {
        if (target != null && !targetSource.isStatic()) {
            // Must have come from TargetSource.
            targetSource.releaseTarget(target);
        }
        if (setProxyContext) {
            // Restore old proxy.
            AopContext.setCurrentProxy(oldProxy);
        }
    }
}


主流程可以简述为：获取可以应用到此方法上的通知链（Interceptor Chain）,如果有,则应用通知,并执行 joinpoint; 如 果没有,则直接反射执行 joinpoint。而这里的关键是通知链是如何获取的以及它又是如何执行的，下面逐一分析下。


首先，从上面的代码可以看到，通知链是通过Advised.getInterceptorsAndDynamicInterceptionAdvice()这个方法来获取 的,我们来看下这个方法的实现:


public List getInterceptorsAndDynamicInterceptionAdvice(Method method, Class targetClass){
    MethodCacheKey cacheKey = new MethodCacheKey(method);
    List cached = this.methodCache.get(cacheKey);
    if (cached == null) {
        cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
        this, method, targetClass);
        this.methodCache.put(cacheKey, cached);
    }
    return cached;
}


可以看到实际的获取工作其实是由 AdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice()这个方法来 完成的，获取到的结果会被缓存。


下面来分析下这个方法的实现：


/**
* 从提供的配置实例 config 中获取 advisor 列表,遍历处理这些 advisor.如果是 IntroductionAdvisor,
* 则判断此 Advisor 能否应用到目标类 targetClass 上.如果是 PointcutAdvisor,则判断
* 此 Advisor 能否应用到目标方法 method 上.将满足条件的 Advisor 通过 AdvisorAdaptor 转化成 Interceptor
列表返回.
*/
public List getInterceptorsAndDynamicInterceptionAdvice(
Advised config, Method method, Class targetClass) {
    // This is somewhat tricky... we have to process introductions first,
    // but we need to preserve order in the ultimate list.
    List interceptorList = new ArrayList(config.getAdvisors().length);
    //查看是否包含 IntroductionAdvisor
    boolean hasIntroductions = hasMatchingIntroductions(config, targetClass);
    //这里实际上注册一系列 AdvisorAdapter,用于将 Advisor 转化成 MethodInterceptor
    AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
    for (Advisor advisor : config.getAdvisors()) {
        if (advisor instanceof PointcutAdvisor) {
            // Add it conditionally.
            PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
            if (config.isPreFiltered() ||
            pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) {
                //这个地方这两个方法的位置可以互换下
                //将 Advisor 转化成 Interceptor
                MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                //检查当前 advisor 的 pointcut 是否可以匹配当前方法
                MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                if (MethodMatchers.matches(mm, method, targetClass, hasIntroductions)) {
                    if (mm.isRuntime()) {
                        // Creating a new object instance in the getInterceptors() method
                        // isn't a problem as we normally cache created chains.
                        for (MethodInterceptor interceptor : interceptors) {
                            interceptorList.add(new
                            InterceptorAndDynamicMethodMatcher(interceptor, mm));
                        }
                    }else {
                        interceptorList.addAll(Arrays.asList(interceptors));
                    }
                }
            }
        }else if (advisor instanceof IntroductionAdvisor) {
            IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
            if (config.isPreFiltered() || ia.getClassFilter().matches(targetClass)) {
            Interceptor[] interceptors = registry.getInterceptors(advisor);
                interceptorList.addAll(Arrays.asList(interceptors));
            }
        }else {
            Interceptor[] interceptors = registry.getInterceptors(advisor);
            interceptorList.addAll(Arrays.asList(interceptors));
        }
    }
    return interceptorList;
}


这个方法执行完成后，Advised 中配置能够应用到连接点或者目标类的 Advisor 全部被转化成了 MethodInterceptor. 接下来我们再看下得到的拦截器链是怎么起作用的。


......
// Check whether we have any advice. If we don't, we can fallback on direct
// reflective invocation of the target, and avoid creating a MethodInvocation.
//如果没有可以应用到此方法的通知(Interceptor)，此直接反射调用 method.invoke(target, args)
if (chain.isEmpty()) {
    // We can skip creating a MethodInvocation: just invoke the target directly
    // Note that the final invoker must be an InvokerInterceptor so we know it does
    // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
    retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
}
else {
    // We need to create a method invocation...
    //创建 MethodInvocation
    invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
    // Proceed to the joinpoint through the interceptor chain.
    retVal = invocation.proceed();
}
......



从这段代码可以看出，如果得到的拦截器链为空，则直接反射调用目标方法，否则创建 MethodInvocation，调用其 proceed方法，触发拦截器链的执行，来看下具体代码


public Object proceed() throws Throwable {
    // We start with an index of -1 and increment early.
    //如果 Interceptor 执行完了，则执行 joinPoint
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint();
    }
    Object interceptorOrInterceptionAdvice =
    this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    //如果要动态匹配 joinPoint
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
        // Evaluate dynamic method matcher here: static part will already have
        // been evaluated and found to match.
        InterceptorAndDynamicMethodMatcher dm =
        (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        //动态匹配：运行时参数是否满足匹配条件
        if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
            //执行当前 Intercetpor
            return dm.interceptor.invoke(this);
        }else {
            // Dynamic matching failed.
            // Skip this interceptor and invoke the next in the chain.
            //动态匹配失败时,略过当前 Intercetpor,调用下一个 Interceptor
            return proceed();
        }
    }else {
        // It's an interceptor, so we just invoke it: The pointcut will have
        // been evaluated statically before this object was constructed.
        //执行当前 Intercetpor
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}

























你可能感兴趣的:(2018-05-19)






    

  • 2018-05-19
夏忠亮

    茶本人爱茶，观色，品铭，闻香，，，，茶就中医讲可提神，降血脂，能有效分解血液中的胆固醇含量。图片发自App沒事邀三五好友，弄个小条桌，烧-壶开水，拿出上好的明前茶，摆上杯子放λ新茶，沏上水，，，，看新芽在水中上下翻腾，￣股股茶香沁人心脾，別有一翻滋味。有茶，有烟男人也就打开了话匣子，聊猴年马月的收成，侃风情往事，戏古往今来王侯将相，骂现实不平之事，，，茶水，一种淡谈的清香，微苦带甜。特别信阳毛尖有
    

    • 

  • 2018-05-19
鸟儿joyce7531

    要进入工作狂的节奏了，今天本来是双休的，但是习惯于早起。由于最近的工作量比较大，还有很多工作没有完成，所以，也早早的起来吃了个早餐就去公司加班了。到了公司后发现，整个办公室就我一个人，这种前所未有的安静工作环境，就像是种享受，不被人打扰的感觉真好，思维不会被中断，写文件的速度也是杠杠的~让我从早上8点半一直奋斗到2点半，才去吃饭。
    

    • 

  • 2018-05-19
洋氵羊

    真想干总会有办法，不想干总会有理由；面对困难，智者想尽千方百计，愚者说尽千言万语；老实人不一定可靠，但可靠的必定是老实人；时间，抓起来是黄金，抓不起来是流水。
    

    • 

  • 2018-05-19
邓姐DD

    摊尸式要求身体放松。处于舒适的仰卧状态。图片发自App图片发自App图片发自App
    

    • 

  • 2018-05-19
正心正德

    卫生部长讲真话，每个人必读!原卫生部部长张文康说得一席话，值得深思。1、送医院的人没死，治几个月人死了，你说是治好了，还是治死了？2、糖尿病：开始一个加号吃了十年的药变成为四个加号，你说是治轻了还是治重了，而且还能坚持十年……3、大夫自己高血压十年，给一年高血压的患者开药方。大夫自己糖尿病五年、痛风八年给发病一年两年的患者治疗，滑稽可笑吧？4、医院大楼越盖越大，病人越来越多，如果医生能够治好病人，
    

    • 

  • 2018-05-19
用思考喂饱生活

    1、跌久必涨，涨久必跌，这是市场。只涨不跌，这是中国楼市。2、房价会跌吗？会跌。什么时候跌？当房地产不再成为国家或者地方的支柱的时候。谁会刺破泡沫？一是经济危机。而是政府。3、楼市火爆有什么好处？政府的收入会增加，地方的经济会增长。楼市不好，会怎么样？房企破产，跑路，烂尾楼增多，政府卖不出地，经济下滑，银行破产，个人收入减少，会更加买不起房，社会动乱。4、为什么调控？政府谋求的只是抑制房价过快上涨
    

    • 

  • 2018-05-19
d3a5c1686c45

    心中有一片净土，那里有阳光、有沙滩、有海浪，有一本书、有一杯茶，没有任何的烦恼与忧愁……图片发自App
    

    • 

  • 2018-05-19 陆奇最新演讲：如何成为一个优秀的工程师
工匠良辰

    一位工程师，如何才能称得上优秀？除了写得一手好Code，什么样的工作态度和方法才是一个优秀工程师的必备？7月11日，陆奇出席百度内部EngineeringLeadershipTalk。作为计算机科学博士及优秀的管理者，他提出的五点要求，对每一位百度工程师都适用。““我们一定要有一个坚定不移的深刻的理念，相信整个世界终究是为技术所驱动的。”“有没有其他人已经解决这个问题？然后你可以把你的时间放在更好
    

    • 

  • 2018-05-19
京心达_周莎

    2018.5.19今日体验:最近的天气不知道该穿什么衣服好，热了就脱，结果感冒了，想想以前自己身体还是可以的，最近总是生病，看来需要加强锻炼了。
    

    • 

  • 2018-05-19
ATonyLi

    姓名：李怀企业名称：上海孚因流体动力设备股份有限公司组别：利他二组(公司反省组)第361期打卡第62天【知~学习】1.《六项精进》4遍共184遍2.《大学》1遍共75遍【经典名句分享】人生本来就是波澜万丈，活着就会遭遇各种困难与挫折。【行~实践】一、修身：（对自己个人）1.学习英语。2.参与读书分享会，了解生命周期，活着的意义。二、齐家：（对家庭和家人）1.给老婆打电话。三、建功（对工作）1.协助
    

    • 

  • 2018-05-19
思小念052

    焦点网络中级郑州坚持分享第116天用愤怒保护自己，远比面对真实的自己容易，身边的亲人也因此成为我们的发泄对象。熊孩子因为花样百出的“熊法”，更容易激发我们的痛苦体验，因而也更容易成为我们愤怒情绪的无辜受害者。
    

    • 

  • 2018-05-19
Q3陈翠玲

    今天是孩子的生日，因为昨天给她发了红包想着让她自己买喜欢的东西，所以我今天也没特意给她买什么礼物。想着她晚自习回来，我一定要给她下碗长寿面吃。我特意下了几首生日之歌想让孩子一进家门就能够听到祝福的歌声。快到下晚自习的点了，老公去接女儿了，这时妹妹跟侄女打来电话，说今天是女儿的生日，呆会要跟她视频，祝福她生日快乐！女儿回来了，非常兴奋手里还抱着同学们送的生日礼物，我赶紧端出寿面让女儿吃，女儿开心的坐
    

    • 

  • 2018-05-19
93650345d0d1

    你可以在年纪轻轻时犯错，并得到周围人的原谅和扶正。但这不是鼓励你去犯错，而是鼓励你去大胆作出尝试。年轻是我们去面对这个世界的资本和优势，而不应该成为你一事无成、固步自封的理由和托辞。每个人都应该珍惜青春的岁月，因为你除了青春，真的没有什么东西可以再失去。
    

    • 

  • 2018-05-19清华大学区块链课堂笔记——钱包
山海星河

    钱包钱包分类及优缺点缺点私钥自己负责比较复杂缺点用户信息不安全优点安全对用户优点私钥交易所负责比较简单对政策安全服务器或钱包
    

    • 

  • 2018-05-19 感恩日记48--儿子发烧没告诉我
中和lxy

    2018年5月19日星期六雨转晴�【早起打卡】4：56【读经汇报】1.《易经》谦卦-随卦2.《唐诗》上031-035首3.《文学启蒙》08学记24.《诗词启蒙》51-60首5.《伤寒论》（二）辨太阳病脉证并治中第六076..太上清静经：1遍，累计99遍。【早安问候】知道只是向往，远方依旧是远方。【生活点滴】中午在吃饭的时候，不知道是因为谈到什么话题，聊到了一件事情，就是说要替对方着想。子千顺口说了
    

    • 

  • 2018-05-19
若水因因

    透过云窗，我望见的是你那慈爱的目光。在那云窗里，正是你洁白如雪，爱我始终如一的心灵。——致母亲图片发自App
    

    • 

  • 2018-05-19
余小刚

    推荐吴军将硅谷高创会的最新内容同步给你——未来超级智能社会有哪些经济特点？区块链有哪些好处又存在哪些问题？哪三类人把比特币炒热？分享自@得到https://m.igetget.com/share/audio/aid/0xyQhtaoGXM5eTJRAXx7
    

    • 

  • 2018-05-19
88e94d537f85

    今天保养一辆别克君越，装修老周的朋友，检查好以后。把该保养的都填好单子，能用的就先用着。这样既提高了客户满意度。同时不会伤害客户。把客户服务好，加油
    

    • 

  • 2018-05-19 函数作用域
杜大个

    函数的作用域变量起作用的代码范围称为变量的作用域，不同作用域内同名变量之间互不影响就像不同文件夹的同名文件间互不影响一样。一个变量在函数外部定义和在内部定义，其作用域是不同的，函数内部定义的变量一般称为局部变量在函数外部定义的变量一般称为去全局变量注意修改全局变量既然全局变量，就是能够在所以的函数中进行使用，那么可否进行修改呢？1、在函数外边定义的变量叫做全局变量2、全局变量能够在所有的函数中进行
    

    • 

  • 2018-05-19
郭家乐

    05,19日精进，体验：今天不忙，干了一些杂活，一天也没有闲下来，核心：时时刻刻让自己忙碌着，转身用：都是工作不挑剔
    

    • 

  • 2018-05-19
玄机喵小姐

    图片发自App图片发自App昨天发了一张小画，收到小伙伴们超多赞和评论。真心的感谢大家的肯定和鼓励。我今天想说说我是怎么开始发现我其实是可以画画的。从小到大我真的没有画过画，美术课我都没有任何的印象了，也从没有人在这方面给过我任何评价，哪怕是负面评价都没有，所以，对于画画，我的内心是阻抗的。但是出于对思维导图的兴趣，我不得不开始第一次临摹。当时连老师推荐的笔都没买，觉得画的也不好，买了就是浪费，用
    

    • 

  • 2018-05-19
拼搏_3792

    往事只能回味......致自己：起早摸黑，忙忙碌碌，就这样一天一天地过着重复的生活…你会发现，只会有人问你挣多少钱？致自己：却很少有人问你累不累？开不开心？生活就是这样，别人只看结果，自己独撑过程。有时你会觉得莫名的累，身累？心累？但所有的累只能一笑而过…...仔细的想想，其实人活着真的不简单。每一天都会发生你想不到的事情，有高兴的、有生气的、有无奈的、有伤心的、有哭笑不得的，有解释不清的…不管是
    

    • 

  • 2018-05-19
一位优雅知性的女子

    不是先看到现象，再去分析本质。而是先有了“本质方法论”，再用来分析现象在分析现象上耗费太多精力纯粹就是浪费时间。比如“人们在消费时会有一种攀比心理”这是一条本质规律，那么商人就会利用这条规律在文案、商品摆放、销售话术等地方上激发消费者的攀比心理，令他们更愿意掏钱。多少年来一直有人持续不断的想寻找什么成功学，我觉得他们其实真正想找的是一种“不用努力就能够成功”的成功学。而很多的人却选择对这些最根本的
    

    • 

  • 2018-05-19 星期六 阴
万山之巅轶涵

    愉快的周末，忙碌的一天，忙碌其实未必不好，忙碌可以让我过的充实，忙碌可以让我离目标更近，忙碌可以让我实现自我的价值……愉快的周末如期而至，今天是女儿跳舞（拉丁舞）考牌的时间，也是这一年来见证业余爱好出成绩的时候，女儿早晨起来，早早的写完作业，说下午考银牌，她要好好练习下，争取今年也得到考官老师的点评。她这种态度我很赞成，最起码每件事情都认真对待，要做就要尽最大努力做饭更好。女儿从下午6点到校，考到
    

    • 

  • 2018-05-19
郭家乐

    05.20日精进，体验：今天维修迈腾空调，压力不够，李经理看了一下，即可就能判断出氟失效了，核心：修车经验，需要观察很多东西，能在最短时间内给客户维修方案，为高手，转身用：人人为师！
    

    • 

  • 2018-05-19
余果_

    问候一声，在座的各位，大家此刻好，可能有些同学还没睡醒或，我们再来一次，问候一声，在座的各位大家此刻好，好，很好，非常好，鬼才商学院真好，耶！真诚的友谊来自于简单的自我介绍，大家好，我叫余果，余是年年有余的余，果是果实的果，希望认识我余果，爱情事业都稳妥。现在天气啊是越来热了，即使在天气这么热的情况下，同学们也是依然在坚持学习，那是因为在热的天气也比不上我们同学热情热，对不对，掌声送给我们最热烈的
    

    • 

  • 2018-05-19跑步感想
大白成长录

    日更打卡（71）去年的一篇记录，现在看看还是很有感触。今天参加了全澄欢乐跑的活动，完成了一次5公里的微马。今年第一次跑的这么爽，现在对我来说跑步也是一种奢侈了。或许是一种借口吧，以后还是要想尽办法，争取每周都能跑一次。今天在跑步过程中有一点感想，特地下来了，以备忘之。跑步和投资有很多相像的地方，或者说投资就是一场长跑。第一，跑步不是比的你跑的有多快，而是看你跑的有多远，投资也一样。今天跑步时，有些
    

    • 

  • 2018-05-19
艾里的日记

    犹犹豫豫小心翼翼又半惊半喜的拥有了自己名下的第一套房子对我一个从小到大都和富裕家庭没什么关系的人来说我对于手头的宽裕和无压力的满足感更为向往对于一身压力把父母的家底儿全部掏空非常抵触我知道自己不对只看眼前风平浪静不顾未来发展和投资收益这绝对是鼠目寸光之举但内心习惯于逃避和自得其乐的属性频频闪现也许未来几年后我会十分感谢当下的自己和母亲也许此刻的我应该是跳跃的新生的欢喜又充满斗志的是该去更好的修为和
    

    • 

  • 2018-05-19，非常之劳碌
大梦斋

    今天值班，然后一刻不得闲的工作。若非值班也停休要来单位加班。而且明天恐怕下不了班。1.今天做了冥想今天早晨做冥想做了一半，惦记着早上的工作，早早去单位。直到晚餐后回宿舍洗澡后，才有时间再次完整进行了一次冥想。2.今天继续读《诗经国风豳风七月》今天仍然继续的听这首诗。然后认真读了，仍然发生在傍晚回宿舍洗澡的间歇。换换脑子。而且发现了一些似曾相识的词语。3.今天继续读《魔鬼数学》关于另外一种彩票期望值
    

    • 

  • 2018-05-19
_Monk

    《算法》射击气球题目要求：https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/思路分析对于某一个气球，至少使用一个弓箭手将它射穿，怎么样才能保证最少的弓箭手？如果射穿某个气球的同时，尽可能多的射穿其他的气球，就可以使用最少的弓箭手怎么才能实现射穿某个气球的同时尽可能多的射穿其他的气
    

    • 

  • 关于旗正规则引擎下载页面需要弹窗保存到本地目录的问题
何必如此
jsp超链接文件下载窗口

    生成下载页面是需要选择“录入提交页面”，生成之后默认的下载页面<a>标签超链接为：<a href="<%=root_stimage%>stimage/image.jsp?filename=<%=strfile234%>&attachname=<%=java.net.URLEncoder.encode(file234filesourc
    

    • 

  • 【Spark九十八】Standalone Cluster Mode下的资源调度源代码分析
bit1129
cluster

    在分析源代码之前，首先对Standalone Cluster Mode的资源调度有一个基本的认识：
首先，运行一个Application需要Driver进程和一组Executor进程。在Standalone Cluster Mode下，Driver和Executor都是在Master的监护下给Worker发消息创建(Driver进程和Executor进程都需要分配内存和CPU，这就需要Maste
    

    • 

  • linux上独立安装部署spark
daizj
linux安装spark1.4部署

    下面讲一下linux上安装spark，以 Standalone Mode 安装
 
1）首先安装JDK
 
下载JDK：jdk-7u79-linux-x64.tar.gz  ，版本是1.7以上都行，解压 tar -zxvf jdk-7u79-linux-x64.tar.gz  
 
然后配置 ~/.bashrc&nb
    

    • 

  • Java 字节码之解析一
周凡杨
java字节码javap

     
 
一： Java 字节代码的组织形式
 
类文件 {
    OxCAFEBABE ，小版本号，大版本号，常量池大小，常量池数组，访问控制标记，当前类信息，父类信息，实现的接口个数，实现的接口信息数组，域个数，域信息数组，方法个数，方法信息数组，属性个数，属性信息数组
}
&nbs
    

    • 

  • java各种小工具代码
g21121
java

    1.数组转换成List
import java.util.Arrays;
Arrays.asList(Object[] obj); 2.判断一个String型是否有值
import org.springframework.util.StringUtils;
if (StringUtils.hasText(str)) 3.判断一个List是否有值
import org.spring
    

    • 

  • 加快FineReport报表设计的几个心得体会
老A不折腾
finereport

    一、从远程服务器大批量取数进行表样设计时，最好按“列顺序”取一个“空的SQL语句”，这样可提高设计速度。否则每次设计时模板均要从远程读取数据，速度相当慢！！
二、找一个富文本编辑软件（如NOTEPAD+）编辑SQL语句，这样会很好地检查语法。有时候带参数较多检查语法复杂时，结合FineReport中生成的日志，再找一个第三方数据库访问软件（如PL/SQL）进行数据检索，可以很快定位语法错误。

    

    • 

  • mysql linux启动与停止
墙头上一根草

    如何启动/停止/重启MySQL一、启动方式1、使用 service 启动：service mysqld start2、使用 mysqld 脚本启动：/etc/inint.d/mysqld start3、使用 safe_mysqld 启动：safe_mysqld&二、停止1、使用 service 启动：service mysqld stop2、使用 mysqld 脚本启动：/etc/inin
    

    • 

  • Spring中事务管理浅谈
aijuans
spring事务管理

    
Spring中事务管理浅谈
By Tony Jiang@2012-1-20 Spring中对事务的声明式管理
拿一个XML举例
[html] 
view plain
copy
print
?
<?xml version="1.0" encoding="UTF-8"?>&nb
    

    • 

  • php中隐形字符65279（utf-8的BOM头）问题
alxw4616

    php中隐形字符65279（utf-8的BOM头）问题
今天遇到一个问题. php输出JSON 前端在解析时发生问题:parsererror.
 
调试:
1.仔细对比字符串发现字符串拼写正确.怀疑是 非打印字符的问题.
2.逐一将字符串还原为unicode编码. 发现在字符串头的位置出现了一个 65279的非打印字符.
 
     
    

    • 

  • 调用对象是否需要传递对象(初学者一定要注意这个问题)
百合不是茶
对象的传递与调用技巧

     
 
类和对象的简单的复习,在做项目的过程中有时候不知道怎样来调用类创建的对象,简单的几个类可以看清楚,一般在项目中创建十几个类往往就不知道怎么来看
 
为了以后能够看清楚,现在来回顾一下类和对象的创建,对象的调用和传递(前面写过一篇)
 
类和对象的基础概念:
 
JAVA中万事万物都是类 类有字段(属性),方法,嵌套类和嵌套接
    

    • 

  • JDK1.5 AtomicLong实例
bijian1013
javathreadjava多线程AtomicLong

    JDK1.5 AtomicLong实例
类 AtomicLong
可以用原子方式更新的 long 值。有关原子变量属性的描述，请参阅 java.util.concurrent.atomic 包规范。AtomicLong 可用在应用程序中（如以原子方式增加的序列号），并且不能用于替换 Long。但是，此类确实扩展了 Number，允许那些处理基于数字类的工具和实用工具进行统一访问。
 
    

    • 

  • 自定义的RPC的Java实现
bijian1013
javarpc

            网上看到纯java实现的RPC，很不错。
        RPC的全名Remote Process Call，即远程过程调用。使用RPC，可以像使用本地的程序一样使用远程服务器上的程序。下面是一个简单的RPC 调用实例，从中可以看到RPC如何
    

    • 

  • 【RPC框架Hessian一】Hessian RPC Hello World
bit1129
Hello world

    什么是Hessian
The Hessian binary web service protocol makes web services usable without requiring a large framework, and without learning yet another alphabet soup of protocols. Because it is a binary p
    

    • 

  • 【Spark九十五】Spark Shell操作Spark SQL
bit1129
shell

    在Spark Shell上，通过创建HiveContext可以直接进行Hive操作
 
1. 操作Hive中已存在的表
 
[hadoop@hadoop bin]$ ./spark-shell
Spark assembly has been built with Hive, including Datanucleus jars on classpath
Welcom
    

    • 

  • F5　往header加入客户端的ip
ronin47

    when HTTP_RESPONSE {if {[HTTP::is_redirect]}{         HTTP::header replace Location [string map {:port/ /} [HTTP::header value Location]]HTTP::header replace Lo
    

    • 

  • java-61-在数组中，数字减去它右边(注意是右边)的数字得到一个数对之差. 求所有数对之差的最大值。例如在数组{2, 4, 1, 16, 7, 5,
bylijinnan
java

    思路来自：
http://zhedahht.blog.163.com/blog/static/2541117420116135376632/
写了个java版的
public class GreatestLeftRightDiff {
/**
* Q61.在数组中，数字减去它右边(注意是右边)的数字得到一个数对之差。
* 求所有数对之差的最大值。例如在数组
    

    • 

  • mongoDB 索引
开窍的石头
mongoDB索引

    在这一节中我们讲讲在mongo中如何创建索引
      得到当前查询的索引信息
     db.user.find(_id:12).explain();
       cursor: basicCoursor 指的是没有索引
 &
    

    • 

  • [硬件和系统]迎峰度夏
comsci
系统

      从这几天的气温来看，今年夏天的高温天气可能会维持在一个比较长的时间内
   所以，从现在开始准备渡过炎热的夏天。。。。
   每间房屋要有一个落地电风扇，一个空调(空调的功率和房间的面积有密切的关系)
   坐的，躺的地方要有凉垫，床上要有凉席
  
   电脑的机箱
    

    • 

  • 基于ThinkPHP开发的公司官网
cuiyadll
行业系统

    后端基于ThinkPHP，前端基于jQuery和BootstrapCo.MZ 企业系统
轻量级企业网站管理系统
运行环境:PHP5.3+, MySQL5.0
系统预览
系统下载：http://www.tecmz.com
预览地址：http://co.tecmz.com
各种设备自适应
响应式的网站设计能够对用户产生友好度，并且对于
    

    • 

  • Transaction and redelivery in JMS (JMS的事务和失败消息重发机制)
darrenzhu
jms事务承认MQacknowledge

    JMS Message Delivery Reliability and Acknowledgement Patterns
http://wso2.com/library/articles/2013/01/jms-message-delivery-reliability-acknowledgement-patterns/
Transaction and redelivery in 
    

    • 

  • Centos添加硬盘完全教程
dcj3sjt126com
linuxcentoshardware

    Linux的硬盘识别:
sda        表示第1块SCSI硬盘
hda       表示第1块IDE硬盘
scd0      表示第1个USB光驱
一般使用“fdisk -l”命
    

    • 

  • yii2 restful web服务路由
dcj3sjt126com
PHPyii2

    路由
随着资源和控制器类准备，您可以使用URL如 http://localhost/index.php?r=user/create访问资源，类似于你可以用正常的Web应用程序做法。
在实践中，你通常要用美观的URL并采取有优势的HTTP动词。 例如，请求POST /users意味着访问user/create动作。 这可以很容易地通过配置urlManager应用程序组件来完成 如下所示
    

    • 

  • MongoDB查询(4)——游标和分页[八]
eksliang
mongodbMongoDB游标MongoDB深分页

    转载请出自出处：http://eksliang.iteye.com/blog/2177567 一、游标
        数据库使用游标返回find的执行结果。客户端对游标的实现通常能够对最终结果进行有效控制，从shell中定义一个游标非常简单，就是将查询结果分配给一个变量（用var声明的变量就是局部变量），便创建了一个游标，如下所示：
> var 
    

    • 

  • Activity的四种启动模式和onNewIntent()
gundumw100
android

    Android中Activity启动模式详解
　　在Android中每个界面都是一个Activity，切换界面操作其实是多个不同Activity之间的实例化操作。在Android中Activity的启动模式决定了Activity的启动运行方式。
　　Android总Activity的启动模式分为四种：
Activity启动模式设置：
<acti
    

    • 

  • 攻城狮送女友的CSS3生日蛋糕
ini
htmlWebhtml5csscss3

    在线预览：http://keleyi.com/keleyi/phtml/html5/29.htm
 
代码如下：
 
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>攻城狮送女友的CSS3生日蛋糕-柯乐义<
    

    • 

  • 读源码学Servlet（1）GenericServlet 源码分析
jzinfo
tomcatWebservlet网络应用网络协议

    Servlet API的核心就是javax.servlet.Servlet接口，所有的Servlet 类（抽象的或者自己写的）都必须实现这个接口。在Servlet接口中定义了5个方法，其中有3个方法是由Servlet 容器在Servlet的生命周期的不同阶段来调用的特定方法。
 
 
先看javax.servlet.servlet接口源码： 
package 
    

    • 

  • JAVA进阶：VO(DTO)与PO(DAO)之间的转换
snoopy7713
javaVOHibernatepo

     
PO即 Persistence Object　　VO即 Value Object
　VO和PO的主要区别在于：　　VO是独立的Java Object。　　PO是由Hibernate纳入其实体容器（Entity Map）的对象，它代表了与数据库中某条记录对应的Hibernate实体，PO的变化在事务提交时将反应到实际数据库中。
　实际上，这个VO被用作Data Transfer 
    

    • 

  • mongodb group by date 聚合查询日期 统计每天数据（信息量）
qiaolevip
每天进步一点点学习永无止境mongodb纵观千象

    /* 1 */
{
"_id" : ObjectId("557ac1e2153c43c320393d9d"),
"msgType" : "text",
"sendTime" : ISODate("2015-06-12T11:26:26.000Z")
    

    • 

  • java之18天 常用的类(一)
Luob.
MathDateSystemRuntimeRundom

    System类
import java.util.Properties;
/**
* System:
* out:标准输出,默认是控制台
* in:标准输入,默认是键盘
*
* 描述系统的一些信息
* 获取系统的属性信息:Properties getProperties();
*
*
*
*/
public class Sy
    

    • 

  • maven
wuai
maven

    1、安装maven：解压缩、添加M2_HOME、添加环境变量path
2、创建maven_home文件夹，创建项目mvn_ch01,在其下面建立src、pom.xml，在src下面简历main、test、main下面建立java文件夹
3、编写类，在java文件夹下面依照类的包逐层创建文件夹，将此类放入最后一级文件夹
4、进入mvn_ch01
4.1、mvn compile ,执行后会在
    

    •