田超凡
田超凡

Spring IOC和AOP整合手写源码总结

                                          Spring IOC和AOP整合手写源码总结

                                                                                                                                                                                     作者：田超凡

                                                                                                                                                                       时间：2019年8月20日

1.maven依赖

因为整个项目是纯手写的，所以只需要依赖Apache的一些工具包，如collection、lang包，以及实现aop动态代理功能的cglib源包

        
            org.apache.commons
            commons-lang3
            3.4
        

        
            commons-collections
            commons-collections
            3.2.1
        

        
            cglib
            cglib
            3.2.5
        

    

 

2.base.properties 属性文件

作用：指定IOC扫描的基准包，一般配置为顶级包，下文IOC实现部分会递归扫描该基准包下的类

base_package=com.tcf.smart.framework.demo

 

3.PropertiesUtil工具类

 作用：

 (1).属性文件工具类，根据指定的属性文件名加载对应的属性文件
 (2).根据Key获取属性值

package com.tcf.smart.framework.util;

import java.io.IOException;
import java.util.Properties;

/***
 * TODO TCF 属性文件工具类，根据指定的属性文件名加载对应的属性文件
 * TODO TCF 根据Key获取属性值
 * @author 71485
 *
 */
public class PropertiesUtil {

    //TODO TCF 采用单例模式-饿汉模式
    private static Properties properties=new Properties();
    
    //TODO TCF 根据属性文件名加载属性文件
    public static Properties loadProperties(String propertiesFileName)
    {
        try
        {
            properties.load(PropertiesUtil.class.getClassLoader().getResourceAsStream(propertiesFileName));
        } 
        catch (IOException e)
        {
            e.printStackTrace();
        }
        
        return properties;
    }
    
    //TODO TCF 根据Key获取属性文件value
    public static String getProperty(String key)
    {
        return properties.getProperty(key);
    }
}

 

4.ClassUtil工具类

作用：

(1).类加载器工具类，获取类加载器、根据类名加载类、根据类名一次加载一个类、根据类名、包路径、包名一次加载所有子类、根据包名加载包及其子包下的所有类文件

package com.tcf.smart.framework.util;

import java.io.File;
import java.io.FileFilter;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import org.apache.commons.lang3.StringUtils;

import com.tcf.smart.framework.common.Const;

/***
 * TODO TCF 类加载器工具类
 * TODO TCF 获取类加载器、根据类名加载类、根据类名一次加载一个类、根据类名、包路径、包名一次加载所有子类、根据包名加载包及其子包下的所有类文件
 * @author 71485
 *
 */
public class ClassUtil {

    //TODO TCF 获取类加载器
    public static ClassLoader getClassLoader()
    {
        return Thread.currentThread().getContextClassLoader();
    }
    
    //TODO TCF 根据类名加载类
    public static Class loadClassByName(String className)
    {
        Class cls=null;
        try
        {
            cls=Class.forName(className,true,getClassLoader());
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        
        return cls;
    }
    
    //TODO TCF 根据类名一次加载一个类
    public static void addSingleClass(Set> classList,String className)
    {
        try
        {
            Class cls=loadClassByName(className);
            classList.add(cls);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
    //TODO TCF 根据包路径和包名递归加载所有类文件
    public static void addClassBatch(Set> classList,String packagePath,String packageName)
    {
        try
        {
            if(StringUtils.isNotEmpty(packagePath))
            {
                //TODO TCF 要扫描的基准目录
                File dirFile=new File(packagePath);
                
                if(dirFile!=null)
                {
                    File[] files=dirFile.listFiles(new FileFilter() {
                        
                        @Override
                        public boolean accept(File file) 
                        {
                            return (file.isFile() && file.getName().endsWith(".class")) || file.isDirectory();
                        }
                    });
                    
                    if(files!=null && files.length>0)
                    {
                        for(File file:files)
                        {
                            String fileName=file.getName();
                            
                            if(StringUtils.isNotEmpty(fileName))
                            {
                                if(file.isFile())
                                {
                                    //TODO TCF 扫描到的类文件加载到类加载器
                                    String className=fileName.substring(0,fileName.lastIndexOf("."));
                                    if(StringUtils.isNotEmpty(packageName))
                                    {
                                        className=packageName+"."+className;
                                    }
                                    
                                    addSingleClass(classList,className);
                                }
                                else
                                {
                                    //TODO TCF 获取子包路径、子包名并递归加载
                                    String subPackagePath=fileName;
                                    if(StringUtils.isNotEmpty(packagePath))
                                    {
                                        subPackagePath=packagePath+"/"+subPackagePath;
                                    }
                                    
                                    String subPackageName=fileName;
                                    if(StringUtils.isNotEmpty(packageName))
                                    {
                                        subPackageName=packageName+"."+subPackageName;
                                    }
                                    
                                    addClassBatch(classList, subPackagePath, subPackageName);
                                }
                            }
                        }
                    }
                }
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
    //TODO TCF 根据包名递归加载所有类文件
    public static Set> loadClassSetByPackageName(String packageName)
    {
        Set> classList=new HashSet>();
        
        try 
        {
            Enumeration urls=getClassLoader().getResources(packageName.replace(".","/"));
            if(urls!=null)
            {
                while(urls.hasMoreElements())
                {
                    URL url=urls.nextElement();
                    
                    if(url!=null)
                    {
                        //TODO TCF URL协议类型
                        String protocol=url.getProtocol();
                        
                        if(StringUtils.isNotEmpty(protocol))
                        {
                            if(protocol.equals(Const.URL_PROTOCOLS.FILE))
                            {
                                //TODO TCF 文件协议
                                String packagePath=url.getPath().replaceAll("%20"," ");
                                addClassBatch(classList, packagePath, packageName);
                            }
                            else if(protocol.equals(Const.URL_PROTOCOLS.JAR))
                            {
                                //TODO TCF JAR包协议
                                JarURLConnection jarURLConnection=(JarURLConnection)url.openConnection();
                                
                                if(jarURLConnection!=null)
                                {
                                    JarFile jarFile=jarURLConnection.getJarFile();
                                    
                                    if(jarFile!=null)
                                    {
                                        Enumeration entries=jarFile.entries();
                                        if(entries!=null)
                                        {
                                            while(entries.hasMoreElements())
                                            {
                                                JarEntry jarEntry=entries.nextElement();
                                                
                                                if(jarEntry!=null)
                                                {
                                                    //TODO TCF jar文件名称
                                                    String entryName=jarEntry.getName();
                                                    
                                                    if(StringUtils.isNotEmpty(entryName) && entryName.endsWith(".class"))
                                                    {
                                                        String className=entryName.substring(0,entryName.lastIndexOf(".")).replace("/",".");
                                                        addSingleClass(classList,className);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        } 
        catch (Exception e) 
        {
            e.printStackTrace();
        }
        
        return classList;
    }
}

 

5.ReflectUtil工具类

作用：

(1).反射工具类，根据类型创建实例、基于反射机制执行对应方法、给对应属性注入属性值

package com.tcf.smart.framework.util;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/***
 * TODO TCF 反射工具类
 * TODO TCF 根据类型创建实例、基于反射机制执行对应方法、给对应属性注入属性值
 * @author 71485
 *
 */
public class ReflectUtil {

    //TODO TCF 根据类型基于反射机制创建对应类型实例
    public static Object newInstance(Class cls)
    {
        Object instance=null;
        
        try
        {
            instance=cls.newInstance();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        
        return instance;
    }
    
    //TODO TCF 基于反射机制给目标属性注入属性值
    public static void setField(Object instance,Field field,Object fieldValue)
    {
        try
        {
            field.setAccessible(true);
            field.set(instance,fieldValue);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
    //TODO TCF 基于反射机制执行目标实例的方法
    public static Object invokeMethod(Object instance,Method method,Object[] methodParams)
    {
        Object result=null;
        
        try
        {
            result=method.invoke(instance,methodParams);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        
        return result;
    }
}
 

6.ClassHelper助手类

作用：

(1).类加载器助手类，初始化加载基准包下的所有类存入临时容器，提供根据注解加载指定类的通用方法，提供根据继承关系加载父类下所有子类或接口所有实现类的方法

package com.tcf.smart.framework.helper;

import java.lang.annotation.Annotation;
import java.util.HashSet;
import java.util.Set;
import com.tcf.smart.framework.annotation.KidComponent;
import com.tcf.smart.framework.annotation.KidController;
import com.tcf.smart.framework.annotation.KidRepository;
import com.tcf.smart.framework.annotation.KidService;
import com.tcf.smart.framework.common.Const;
import com.tcf.smart.framework.util.ClassUtil;
import com.tcf.smart.framework.util.PropertiesUtil;

/**
 * TODO TCF 类加载器助手类
 * TODO TCF 初始化加载基准包下的所有类存入临时容器，提供根据注解加载指定类的通用方法，提供根据继承关系加载父类下所有子类或接口所有实现类的方法
 * @author 71485
 *
 */
public class ClassHelper {

    public static Set> CLASS_LIST=new HashSet>();
    
    static
    {
        CLASS_LIST=ClassUtil.loadClassSetByPackageName(PropertiesUtil.loadProperties(Const.PROPERTIES_FILES.BASE_PROPERTIES).getProperty(Const.BASE_KEYS.BASE_PACKAGE));
    }
    
    //TODO TCF 根据注解加载对应类
    public static Set> loadClassByAnnotation(Class annotation)
    {
        Set> classList=new HashSet>();
        
        if(CLASS_LIST!=null && CLASS_LIST.size()>0)
        {
            for(Class cls:CLASS_LIST)
            {
                if(cls.isAnnotationPresent(annotation))
                {
                    classList.add(cls);
                }
            }
        }
        
        return classList;
    }
    
    //TODO TCF 根据父类或接口加载其子类或实现类
    public static Set> loadClassBySuperClass(Class superClass)
    {
        Set> classList=new HashSet>();
        
        if(CLASS_LIST!=null && CLASS_LIST.size()>0)
        {
            for(Class cls:CLASS_LIST)
            {
                if(superClass.isAssignableFrom(cls) && !superClass.equals(cls))
                {
                    classList.add(cls);
                }
            }
        }
        
        return classList;
    }
    
    //TODO TCF 加载预定义的注解标注类
    public static Set> loadClassExample()
    {
        Set> classList=new HashSet>();
        
        classList.addAll(loadClassByAnnotation(KidComponent.class));
        classList.addAll(loadClassByAnnotation(KidRepository.class));
        classList.addAll(loadClassByAnnotation(KidService.class));
        classList.addAll(loadClassByAnnotation(KidController.class));
        
        return classList;
    }
}
 

7.BeanHelper助手类

作用：

(1).自定义Bean组件及Bean实例映射管理工具类
(2).初始化加载Bean组件及其对应Bean实例，提供根据Bean类型获取Bean实例方法，提供存取元素方法

package com.tcf.smart.framework.helper;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/***
 * TODO TCF 自定义Bean组件及Bean实例映射管理工具类
 * TODO TCF 初始化加载Bean组件及其对应Bean实例，提供根据Bean类型获取Bean实例方法，提供存取元素方法
 * @author 71485
 *
 */
public class BeanHelper {

    public static Map,Object> BEAN_MAP=new HashMap,Object>();
    
    static
    {
        Set> classList=ClassHelper.CLASS_LIST;
        if(classList!=null && classList.size()>0)
        {
            for(Class cls:classList)
            {
                try 
                {
                    Object instance=cls.newInstance();
                    BEAN_MAP.put(cls,instance);
                } 
                catch (Exception e) 
                {
                    e.printStackTrace();
                }
            }
        }
    }
    
    //TODO TCF 根据Bean类型获取Bean实例
    public static Object getBeanByClass(Class cls)
    {
        return BEAN_MAP.get(cls);
    }
    
    //TODO TCF 存入Bean组件和Bean实例映射元素
    public static void putBeanMapping(Class cls,Object instance)
    {
        BEAN_MAP.put(cls,instance);
    }
}

 

8.SpringIOC类加载器：IocHelper

作用：

(1).DI/IOC依赖注入助手类，加载基准包下的类并注入属性值，反射方法进行调用

package com.tcf.smart.framework.helper;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import com.tcf.smart.framework.annotation.Aspect;
import com.tcf.smart.framework.annotation.KidController;
import com.tcf.smart.framework.annotation.KidInject;
import com.tcf.smart.framework.demo.TestDemoFirst;
import com.tcf.smart.framework.demo.TestDemoSecond;
import com.tcf.smart.framework.demo.TestDemoThird;
import com.tcf.smart.framework.util.ReflectUtil;

/***
 * TODO TCF DI/IOC依赖注入助手类，加载基准包下的类并注入属性值，反射方法进行调用
 * @author 71485
 *
 */
public class IocHelper {

    static
    {
        //TODO TCF simpleClassName => fieldName:fieldValue
        Map> fieldMap=new HashMap>();
        
        //TODO TCF 需要注入的属性名：属性值
        Map paramMap=new HashMap();
        paramMap.put("name","张三");
        fieldMap.put(TestDemoFirst.class.getSimpleName(),paramMap);
        
        paramMap=new HashMap();
        paramMap.put("age",18);
        fieldMap.put(TestDemoSecond.class.getSimpleName(),paramMap);
        
        paramMap=new HashMap();
        paramMap.put("first",new TestDemoFirst());
        fieldMap.put(TestDemoThird.class.getSimpleName(),paramMap);
        
        //TODO TCF 启动容器，实现DI/IOC依赖注入
        init(fieldMap);
    }
    
    //TODO TCF DI/IOC容器启动
    public static void init(Map> fieldMap)
    {
        //TODO TCF 获取Bean组件和实例映射Map
        Map,Object> beanMap=BeanHelper.BEAN_MAP;
        
        if(beanMap!=null)
        {
            for(Map.Entry,Object> entry:beanMap.entrySet())
            {
                //TODO TCF 目标类型
                Class targetClass=entry.getKey();
                
                //TODO TCF 过滤AOP已经加载的代理类
                if(targetClass.isAnnotationPresent(Aspect.class))
                {
                    continue;
                }
                
                //TODO TCF 目标类型实例
                Object instance=entry.getValue();
                
                //TODO TCF 目标类型下面定义的所有属性
                Field[] fields=targetClass.getDeclaredFields();
                
                if(fields!=null && fields.length>0)
                {
                    for(Field field:fields)
                    {
                        if(field.isAnnotationPresent(KidInject.class))
                        {
                            //TODO TCF 参数注入使用KidInject注解标注的属性
                            for(Map.Entry> fieldEntry:fieldMap.entrySet())
                            {
                                //TODO TCF 属性所在类型名称
                                String className=fieldEntry.getKey();
                                
                                //TODO TCF 属性KEY-VALUE键值对
                                Map paramMap=fieldEntry.getValue();
                            
                                if(StringUtils.isNotEmpty(className))
                                {
                                    if(className.equals(targetClass.getSimpleName()))
                                    {
                                        //TODO TCF 注入属性值
                                        for(Map.Entry destEntry:paramMap.entrySet())
                                        {
                                            //TODO TCF 属性值
                                            Object fieldValue=destEntry.getValue();
                                            
                                            //TODO TCF 注入属性值
                                            ReflectUtil.setField(instance, field, fieldValue);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                
                //TODO TCF 只执行AOP代理的控制器方法
                //TODO TCF 实际可以去掉该条件或换成其他条件，满足条件的目标类中的方法会被执行
                if(targetClass.isAnnotationPresent(KidController.class))
                {
                    //TODO TCF 反射执行目标方法
                    Method[] methods=targetClass.getDeclaredMethods();
                    if(methods!=null && methods.length>0)
                    {
                        for(Method method:methods)
                        {
                            //TODO TCF 方法参数
                            Object[] methodParams=null;
                            
                            //TODO TCF ...方法入参补全
                            ReflectUtil.invokeMethod(instance, method, methodParams);
                        }
                    }
                }
            }
        }
    }
}


9.注解定义类

作用：自定义项目需要使用的注解及其功能

@KidComponent 注册普通组件 => @Component

@KidRepository 注册持久层组件 => @Repository

@KidService 注册业务层组件 => @Service

@KidController 注册控制器组件 => @Controller

@KidInject 显式指定需要注入值的属性 => @Inject

@Aspect 定义切面类 => @Aspect

package com.tcf.smart.framework.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface KidComponent {

}
 

package com.tcf.smart.framework.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface KidRepository {

}

package com.tcf.smart.framework.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface KidService {

}
 

package com.tcf.smart.framework.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface KidInject {

}
 

package com.tcf.smart.framework.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface KidController {

}
 

package com.tcf.smart.framework.annotation;

import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Aspect {

    //TODO TCF 获取切面注解值
    Class value();
}
 

10.常量类Const

package com.tcf.smart.framework.common;
/***
 * TODO TCF 常量类
 * @author 71485
 *
 */
public class Const {

    //TODO TCF 属性配置文件名
    public static class PROPERTIES_FILES
    {
        //TODO TCF IOC和AOP配置文件
        public static final String BASE_PROPERTIES="base.properties";
    }
    
    //TODO TCF URL协议类型
    public static class URL_PROTOCOLS
    {
        //TODO TCF file文件协议
        public static final String FILE="file";
        
        //TODO TCF jar文件协议
        public static final String JAR="jar";
    }
    
    //TODO TCF 属性文件key
    public static class BASE_KEYS
    {
        //TODO TCF 基准包目录
        public static final String BASE_PACKAGE="base_package";
    }
}
 

11.AOP代理接口

作用：

(1).代理接口，定义封装的切面方法织入各类增强，调用代理实例的执行链依次执行代理方法

package com.tcf.smart.framework.aop;

/**
 * TODO TCF 代理接口，定义封装的切面方法织入各类增强，调用代理实例的执行链依次执行代理方法
 * @author 71485
 *
 */
public interface Proxy {

    //TODO TCF 执行增强方法
    public Object doProxy(ProxyChain proxyChain);
}
 

12.AOP代理执行链

作用:

(1).代理实例执行链，跟踪代理实例执行顺序

package com.tcf.smart.framework.aop;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

import net.sf.cglib.proxy.MethodProxy;

/***
 * TODO TCF 代理实例执行链，跟踪代理实例执行顺序
 * @author 71485
 *
 */
public class ProxyChain {

    //TODO TCF 代理目标类型
    private Class targetClass;
    
    //TODO TCF 代理目标实例
    private Object targetInsatnce;
    
    //TODO TCF 代理目标方法
    private Method targetMethod;
    
    //TODO TCF 代理方法
    private MethodProxy methodProxy;
    
    //TODO TCF 方法参数
    private Object[] methodParams;
    
    //TODO TCF 存放代理实例的集合
    private List proxyList=new ArrayList();
    
    //TODO TCF 记录执行链执行索引
    private static Integer proxyExecuteIndex=0;
    
    //TODO TCF 获取代理目标类型、目标实例、目标方法、方法参数
    public Class getTargetClass() {
        return targetClass;
    }
    public Object getTargetInsatnce() {
        return targetInsatnce;
    }
    public Method getTargetMethod() {
        return targetMethod;
    }
    public Object[] getMethodParams() {
        return methodParams;
    }
    public List getProxyList() {
        return proxyList;
    }
    
    //TODO TCF 构造注入代理信息
    public ProxyChain(
                 Class targetClass,
                 Object targetInstance,
                 Method targetMethod,
                 MethodProxy methodProxy,
                 Object[] methodParams,
                 List proxyList
            )
    {
        this.targetClass=targetClass;
        this.targetInsatnce=targetInstance;
        this.targetMethod=targetMethod;
        this.methodProxy=methodProxy;
        this.methodParams=methodParams;
        this.proxyList=proxyList;
    }
    
    //TODO TCF 代理执行链启动
    public Object doProxyChain()
    {
        Object result=null;
        if(proxyExecuteIndex         {
            result=proxyList.get(proxyExecuteIndex++).doProxy(this);
        }
        else
        {
            try 
            {
                result=methodProxy.invokeSuper(targetInsatnce,methodParams);
            } 
            catch (Throwable e) 
            {
                e.printStackTrace();
            }
        }
        
        return result;
    }
}
 

13.CGLIB代理工厂ProxyManager

作用:

(1).代理模式工厂类，基于cglib创建多个代理实例并执行对应代理方法

package com.tcf.smart.framework.aop;

import java.lang.reflect.Method;
import java.util.List;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
 * TODO TCF 代理模式工厂类，基于cglib创建多个代理实例并执行对应代理方法
 * @author 71485
 *
 */
public class ProxyManager {

    @SuppressWarnings("unchecked")
    public static T newProxyInstance(Class targetClass,List proxyList)
    {
        return (T) Enhancer.create(targetClass,new MethodInterceptor() {
            
            @Override
            public Object intercept(Object targetInstance, 
                    Method targetMethod, 
                    Object[] methodParams,
                    MethodProxy methodProxy) throws Throwable
            {
                return new ProxyChain(targetClass, targetInstance, targetMethod, methodProxy, methodParams, proxyList).doProxyChain();
            }
            
        });
    }
}

 

14.封装后的通用切面类ProxyAspect

作用:

(1).切面基类，定义通用的各类增强处理方法，其他切面类直接继承该类重写对应增强处理即可

package com.tcf.smart.framework.aop;

/***
 * TODO TCF 切面基类，定义通用的各类增强处理方法，其他切面类直接继承该类重写对应增强处理即可
 * @author 71485
 *
 */
public abstract class ProxyAspect implements Proxy{

    @Override
    public Object doProxy(ProxyChain proxyChain) 
    {
        Object result=null;
        
        //TODO TCF 织入增强处理
        try
        {
            before();
            result=proxyChain.doProxyChain();
            after();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        
        return result;
    }
    
    //TODO TCF 自定义各类增强处理
    //TODO TCF 前置增强
    public void before()
    {
        System.out.println("====前置增强 before====");
    }
    
    //TODO TCF 后置增强
    public void after()
    {
        System.out.println("====后置增强 afterReturning====");
    }
}
 

15.AOP核心控制器(助手类)AopHelper

作用:

(1).AOP切面助手类
(2).初始化加载所有基准包下的目标类及其对应的代理类，批量创建每个目标类的多个代理实例并调用对应的代理方法执行(织入增强处理效果)

package com.tcf.smart.framework.helper;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.tcf.smart.framework.annotation.Aspect;
import com.tcf.smart.framework.aop.Proxy;
import com.tcf.smart.framework.aop.ProxyAspect;
import com.tcf.smart.framework.aop.ProxyManager;

/***
 * TODO TCF AOP切面助手类
 * TODO TCF 初始化加载所有基准包下的目标类及其对应的代理类，批量创建每个目标类的多个代理实例并调用对应的代理方法执行(织入增强处理效果)
 * @author 71485
 *
 */
public class AopHelper {

    static
    {
        //TODO TCF 加载基准包下的所有代理类
        //TODO TCF 代理类：代理的所有目标类
        Map,Set>> proxyMap=createProxyMap();
        
        //TODO TCF 目标类：目标类的所有代理类
        Map,List> targetMap=createTargetMap(proxyMap);
        
        if(targetMap!=null)
        {
            for(Map.Entry,List> entry:targetMap.entrySet())
            {
                //TODO TCF 目标类
                Class targetClass=entry.getKey();
                
                //TODO TCF 目标类的所有代理类
                List proxyList=entry.getValue();
                
                //TODO TCF 批量创建cglib代理实例
                Object result=ProxyManager.newProxyInstance(targetClass, proxyList);
                
                //TODO TCF 存入Bean组件和Bean实例映射(目标类的实例使用创建的代理实例);
                BeanHelper.putBeanMapping(targetClass,result);
            }
        }
    } 
    
    //TODO TCF 读取切面子类(目标类)
    public static Set> loadByAspect(Aspect aspect)
    {
        Set> classList=new HashSet>();
        
        Class annotation=aspect.value();
        
        if(annotation!=null && !annotation.equals(Aspect.class))
        {
            classList.addAll(ClassHelper.loadClassByAnnotation(annotation));
        }
        
        return classList;
    }
    
    //TODO TCF 读取代理类:代理的所有目标类
    public static Map,Set>> createProxyMap()
    {
        Map,Set>> proxyMap=new HashMap, Set>>();
        
        //TODO TCF 代理的所有目标类
        Set> classList=ClassHelper.loadClassBySuperClass(ProxyAspect.class);
    
        if(classList!=null)
        {
            for(Class proxyClass:classList)
            {
                if(proxyClass.isAnnotationPresent(Aspect.class))
                {
                    Aspect aspect=proxyClass.getAnnotation(Aspect.class);
                    
                    Set> targetClassList=loadByAspect(aspect);
                    
                    proxyMap.put(proxyClass,targetClassList);
                }
            }
        }
        
        return proxyMap;
    }
    
    //TODO TCF 读取目标类，目标的所有代理类
    public static Map,List> createTargetMap(Map,Set>> proxyMap)
    {
        Map,List> targetMap=new HashMap,List>();
        
        if(proxyMap!=null)
        {
            for(Map.Entry,Set>> entry:proxyMap.entrySet())
            {
                //TODO TCF 代理类
                Class proxyClass=entry.getKey();
                
                //TODO TCF 代理的所有目标类
                Set> targetClassList=entry.getValue();
                
                for(Class targetClass:targetClassList)
                {
                    try 
                    {
                        Proxy proxy=(Proxy)proxyClass.newInstance();
                        
                        if(targetMap.containsKey(targetClass))
                        {
                            targetMap.get(targetClass).add(proxy);
                        }
                        else
                        {
                            List proxyList=new ArrayList();
                            proxyList.add(proxy);
                            targetMap.put(targetClass,proxyList);
                        }
                    } 
                    catch (Exception e) 
                    {
                        e.printStackTrace();
                    }
                }
            }
        }
        
        return targetMap;
    }
}
 

 

你可能感兴趣的:(Spring框架,动态代理,设计模式,JavaEE)

  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式java
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException 屿小夏 java开发语言
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
  • 设计模式 23 访问者模式 WineMonk #设计模式设计模式访问者模式
    设计模式23创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式23访问者模式（VisitorPattern）1定义2结构3
  • 设计模式】Listener模式和Visitor模式的区别 不爱洗脚的小滕 设计模式访问者模式javagolang
    文章目录前言一、介绍Listener模式Visitor模式二、代码实现2.1Listener模式的Java实现2.2Listener模式的Go实现2.3Visitor模式的Java实现2.4Visitor模式的Go实现三、总结前言在软件设计中，设计模式是解决特定问题的通用解决方案。Listener模式和Visitor模式是两种常见的行为设计模式，它们在不同的场景下提供了解决问题的有效方法。本文将详
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • 从单体到微服务：FastAPI ‘挂载’子应用程序的转变 黑金IT fastapi微服务fastapi架构
    在现代Web应用开发中，模块化架构是一种常见的设计模式，它有助于将大型应用程序分解为更小、更易于管理的部分。FastAPI，作为一个高性能的PythonWeb框架，提供了强大的支持来实现这种模块化设计。通过“挂载”子应用程序，我们可以为不同的功能区域（如前端接口、管理员接口和用户中心）创建独立的应用程序，并将它们整合到一个主应用程序中。本文将详细介绍如何在FastAPI中使用“挂载”子应用程序的方
  • [面试高频问题]关于多线程的单例模式 朱玥玥要每天学习 java单例模式开发语言
    单例模式什么是设计模式?设计模式可以看做为框架或者是围棋中的”棋谱”,红方当头炮,黑方马来跳.根据一些固定的套路下,能保证局势不会吃亏.在日常的程序设计中,往往有许多业务场景,根据这些场景,大佬们总结出了一些固定的套路.按照这个套路来实现代码,也不会吃亏.什么是单例模式,保证某类在程序中只有一个实例,而不会创建多份实例.单例模式具体的实现方式:可分为”懒汉模式”,”饿汉模式”.饿汉模式类加载的同时
  • 从简单到复杂：三种工厂模式的对比与应用 技术拾光者 设计模式java设计模式简单工厂模式抽象工厂模式工厂方法模式
    在软件设计中，创建型设计模式用于处理对象创建的复杂性。本文将对比三种常见的创建型设计模式：简单工厂模式、工厂方法模式和抽象工厂模式。一，简单工厂模式定义：简单工厂模式（SimpleFactoryPattern）定义了一个工厂类，该类可以根据传入的参数决定创建哪一种产品实例。结构：产品（Product）：定义产品的接口。具体产品（ConcreteProduct）：实现具体产品。工厂（Factory）
  • java 技术 架构 相关文档 圣心 java架构开发语言
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
  • 当前最流行的架构设计模式 turingbooks
    《微服务设计（第2版）》最可贵的地方在于，不光具备理论性与系统性，更为注重实践性与可操作性。全书勾勒出一幅从宏观到细节，再到组织落地的微服务架构整体实施蓝图。无论是对关注微服务领域的工程师与架构师，还是对寻求架构升级的管理者与决策者来说，本书都可以作为指导手册。——沈剑，快狗打车CTO《微服务设计（第2版）》萨姆·纽曼|著钟健鑫张沙沙智伟|译软件开发大神MartinFowler如此推荐本书：“微服
  • 互联网 Java 工程师面试题（Java 面试题四） 苹果酱0567 面试题汇总与解析java中间件开发语言springboot后端
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • Spring1-概述 Onlooker129 Springspring
    目录Spring是什么Spring的狭义和广义SpringFramework特点Spring模块组成Spring是什么Spring是一款主流的JavaEE轻量级开源框架，Spring由“Spring之父”RodJohnson提出并创立，其目的是用于简化Java企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Sp
  • Java中的服务端点响应缓存：Spring Cache抽象 微赚淘客机器人开发者联盟@聚娃科技 java缓存spring
    Java中的服务端点响应缓存：SpringCache抽象大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在Java后端服务开发中，缓存是一个重要的性能优化手段。Spring框架提供了一个强大的缓存抽象，允许开发者以统一的方式使用不同的缓存技术。本文将介绍如何在Java应用中使用SpringCache抽象来实现服务端点的响应缓存。响应缓存的重要性响应缓存在服务端点中
  • MyBatis 方法重载的陷阱及解决方案 molashaonian mybatis方法重载异常方法名相同
    在使用MyBatis进行开发时，尤其是使用注解模式（如@Select、@Insert等）时，开发者常常会遇到这样一个问题：为什么我的方法重载不能正常工作？即使在Java中允许方法名相同但参数不同的重载，MyBatis在处理注解的SQL方法时却并不支持这种方式。这篇文章将深入探讨MyBatis的这个特性及如何规避相关的坑。问题背景在标准的Java开发中，方法重载是一种常见的设计模式。方法重载允许我们
  • 【设计模式】结构型模式：组合模式 KunQAQrz
    意图使用组合模式可以将对象组合成树状结构，并且能像使用独立对象一样使用它们。组合模式结构在这里插入图片描述组件（Component）接口描述了树中简单项目和复杂项目所共有的操作。叶节点（Leaf）是树的基本结构，它不包含子项目。一般情况下，叶节点最终会完成大部分的实际工作，因为它们无法将工作指派给其他部分。容器（Container）又名“组合（Composite）”是包含叶节点或其他容器等子项目的
  • Java高并发编程详解系列-Balking设计模式 nihui123 高并发设计模式java编程语言
    导语  在实际操作中当某个线程因为发现其他线程正在进行相同的工作而放弃即将开始的任务，这种情况就被称为是Balking模式，Balking英文的意思是犹豫。在多个线程监控某个共享变量，A线程监控到共享变量发生变化后立即触发某个动作，但是这个这个时候发现了B线程也对该变量开始了行动，这个时候A变量就放弃了准备工作。下面就来详细的讲解一下关于Balking模式什么是Balking模式  在餐厅吃饭的时
  • Java高并发编程详解系列-Future设计模式 nihui123 高并发Java高并发Future高并发
    导语  假设，在一个使用场景中有一个任务需要执行比较长的时间，通常需要等待任务执行结束之后或者是中途出错之后才能返回结果。在这个期间调用者只能等待，对于这个结果Future设计模式提供了一种凭据式的解决方案。在日常生活中，这种方案也是存在的。例如去洗衣店洗衣服，当你把衣服放到洗衣店，等他洗完需要一段时间，这个时候洗衣店就会给你一凭证，你可以通过这个凭证到时候去取洗好的衣服。这个例子就是生活中的Fu
  • 字节跳动面试官亲述：Android开发学会了这些技术，你离大厂不远了 m0_65322636 程序员架构移动开发android
    HTTPSHTTP是超文本传输协议，明文传输；HTTPS使用SSL协议对HTTP传输数据进行了加密HTTP默认80端口；HTTPS默认443端口优点：安全缺点：费时、SSL证书收费，加密能力还是有限的，但是比HTTP强多了2、Java基础&容器&同步&设计模式StringBuilder、StringBuffer、+、String.concat链接字符串：StringBuffer线程安全，Strin
  • 生产者消费者模式_Labview基础之生产者消费者设计模式（事件） weixin_39532699 生产者消费者模式
    1绪论近期，开了一个QQ群，刚开始的目的也是想多拉写软件相关的大神，有问题的时候也可以交流交流。记得当时有个软件在写的时候遇到了一个棘手的问题，outlook邮箱配置账户密码的问题，到现在也没解决，算了，也不是很迫切。2000人群就留在那里爬虫发单吧！建群以后才发现，原来这一块的小白还挺多，总结起来就一个原因：做这个软件的大多数都不是软件出生，都是因为临时要搭建一个上位机平台，匆匆入门......
  • Java Spring Boot 全面教程 极客代码 玩转Javajavaspringboot开发语言后端
    一、SpringBoot简介与环境搭建1.1SpringBoot简介SpringBoot是一种基于Java的开源框架，由PivotalSoftware开发，旨在简化新Spring应用程序的初始化、配置和部署过程。它遵循约定优于配置的原则，通过内嵌的Tomcat、Jetty或Undertow等容器，使得开发者能够快速构建独立运行的、生产级别的基于Spring框架的应用程序。SpringBoot包含了
  • Spring6学习笔记4：事务 ·云扬· SSMJava#Spring学习笔记spring
    1JdbcTemplate1.1简介Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作准备工作①搭建子模块搭建子模块：spring-jdbc-tx②加入依赖org.springframeworkspring-jdbc6.0.2mysqlmysql-connector-java8.0.30com.alibabadruid1.2.15③创建jdbc.propertie
  • java中的ide、sdk是什么,javaee\javase\javame区别 极客Thomas idejavaeclipse
    ide：integrateddevelopmentenvironment集成开发环境简单的来说就是提供编译代码等一系列功能的开发环境比如：eclipsesdk：servicedevelopmentpack服务开发包简单来说就是一些封装的功能代码，做成了一个包，给我们可以直接调用比如jdk1.8jdkjavase（JavaPlatform，StandardEdition）标准版本，在电脑上运行jav
  • 案例分析：如何用设计模式优化性能7 是小旭啊 fastapi
    设计模式就是对常用开发技巧进行的总结，它使得程序员之间交流问题，有了更专业、便捷的方式。比如，我们在《02|理论分析：性能优化有章可循，谈谈常用的切入点》中提到，I/O模块使用的是装饰器模式，你就能很容易想到I/O模块的代码组织方式。事实上，大多数设计模式并不能增加程序的性能，它只是代码的一种组织方式。本课时，我们将一一举例讲解和性能相关的几个设计模式，包括代理模式、单例模式、享元模式、原型模式等
  • 【Spring】Spring中@Component和@Bean的区别？ 九师兄 框架-springbootspringjava后端
    1.概述在Spring框架中，@Component和@Bean是两个常用的注解，用于实现组件的声明和配置。它们的主要区别如下：作用对象不同：@Component注解用于声明一个类为Spring容器的组件（Bean），Spring会自动扫描并将其实例化为Bean并管理。@Bean注解用于在配置类（通常是带有@Configuration注解的类）中声明一个方法，该方法的返回值将被注册为Spring容器
  • 重修设计模式-结构型-代理模式 丶白泽 重修设计模式设计模式代理模式系统安全
    重修设计模式-结构型-代理模式在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。代理模式通过创建一个代理对象，使得客户端对目标对象的访问都通过代理对象间接进行，从而可以在不修改目标对象的前提下，增加额外的功能操作，如权限控制、日志记录、事务处理等。代理模式又分为静态代理和动态代理。静态代理（StaticProxy）：在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前
  • Algorithm 香水浓 javaAlgorithm
    冒泡排序 public static void sort(Integer[] param) { for (int i = param.length - 1; i > 0; i--) { for (int j = 0; j < i; j++) { int current = param[j]; int next = param[j + 1];
  • mongoDB 复杂查询表达式 开窍的石头 mongodb
    1:count    Pg: db.user.find().count();    统计多少条数据 2:不等于$ne    Pg: db.user.find({_id:{$ne:3}},{name:1,sex:1,_id:0});    查询id不等于3的数据。 3：大于$gt $gte(大于等于) &n
  • Jboss Java heap space异常解决方法, jboss OutOfMemoryError : PermGen space 0624chenhong jvmjboss
    转自 http://blog.csdn.net/zou274/article/details/5552630 解决办法： window->preferences->java->installed jres->edit jre 把default vm arguments 的参数设为-Xms64m -Xmx512m ----------------
  • 文件上传 下载 解析 相对路径 不懂事的小屁孩 文件上传
    有点坑吧，弄这么一个简单的东西弄了一天多，身边还有大神指导着，网上各种百度着。 下面总结一下遇到的问题： 文件上传，在页面上传的时候，不要想着去操作绝对路径，浏览器会对客户端的信息进行保护，避免用户信息收到攻击。 在上传图片，或者文件时，使用form表单来操作。 前台通过form表单传输一个流到后台，而不是ajax传递参数到后台，代码如下: <form action=&
  • 怎么实现qq空间批量点赞 换个号韩国红果果 qq
    纯粹为了好玩！！ 逻辑很简单 1 打开浏览器console；输入以下代码。 先上添加赞的代码 var tools={}; //添加所有赞 function init(){ document.body.scrollTop=10000; setTimeout(function(){document.body.scrollTop=0;},2000);//加
  • 判断是否为中文 灵静志远 中文
    方法一： public class Zhidao { public static void main(String args[]) { String s = "sdf灭礌 kjl d{';\fdsjlk是"; int n=0; for(int i=0; i<s.length(); i++) { n = (int)s.charAt(i); if((
  • 一个电话面试后总结 a-john 面试
    今天，接了一个电话面试，对于还是初学者的我来说，紧张了半天。 面试的问题分了层次，对于一类问题，由简到难。自己觉得回答不好的地方作了一下总结：   在谈到集合类的时候，举几个常用的集合类，想都没想，直接说了list,map。   然后对list和map分别举几个类型：   list方面：ArrayList,LinkedList。在谈到他们的区别时，愣住了
  • MSSQL中Escape转义的使用 aijuans MSSQL
    IF OBJECT_ID('tempdb..#ABC') is not null drop table tempdb..#ABC create table #ABC ( PATHNAME NVARCHAR(50) ) insert into #ABC SELECT N'/ABCDEFGHI' UNION ALL SELECT N'/ABCDGAFGASASSDFA' UNION ALL
  • 一个简单的存储过程 asialee mysql存储过程构造数据批量插入
               今天要批量的生成一批测试数据，其中中间有部分数据是变化的，本来想写个程序来生成的，后来想到存储过程就可以搞定，所以随手写了一个，记录在此：            DELIMITER $$ DROP PROCEDURE IF EXISTS inse
  • annot convert from HomeFragment_1 to Fragment 百合不是茶 android导包错误
    创建了几个类继承Fragment, 需要将创建的类存储在ArrayList<Fragment>中; 出现不能将new 出来的对象放到队列中,原因很简单;     创建类时引入包是:import android.app.Fragment;      创建队列和对象时使用的包是:import android.support.v4.ap
  • Weblogic10两种修改端口的方法 bijian1013 weblogic端口号配置管理config.xml
    一.进入控制台进行修改    1.进入控制台:  http://127.0.0.1:7001/console     2.展开左边树菜单         域结构->环境->服务器-->点击AdminServer(管理) &
  • mysql 操作指令 征客丶 mysql
    一、连接mysql 进入 mysql 的安装目录； $ bin/mysql -p [host IP 如果是登录本地的mysql 可以不写 -p 直接 -u] -u [userName] -p 输入密码，回车，接连； 二、权限操作［如果你很了解mysql数据库后，你可以直接去修改系统表，然后用 mysql> flush privileges; 指令让权限生效］ 1、赋权 mys
  • 【Hive一】Hive入门 bit1129 hive
    Hive安装与配置 Hive的运行需要依赖于Hadoop，因此需要首先安装Hadoop2.5.2，并且Hive的启动前需要首先启动Hadoop。   Hive安装和配置的步骤   1. 从如下地址下载Hive0.14.0   http://mirror.bit.edu.cn/apache/hive/    2.解压hive，在系统变
  • ajax 三种提交请求的方法 BlueSkator Ajaxjqery
    1、ajax 提交请求 $.ajax({ type:"post", url : "${ctx}/front/Hotel/getAllHotelByAjax.do", dataType : "json", success : function(result) { try { for(v
  • mongodb开发环境下的搭建入门 braveCS 运维
      linux下安装mongodb 1）官网下载mongodb-linux-x86_64-rhel62-3.0.4.gz 2）linux 解压  gzip -d mongodb-linux-x86_64-rhel62-3.0.4.gz; mv mongodb-linux-x86_64-rhel62-3.0.4 mongodb-linux-x86_64-rhel62-
  • 编程之美-最短摘要的生成 bylijinnan java数据结构算法编程之美
    import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; public class ShortestAbstract { /** * 编程之美 最短摘要的生成 * 扫描过程始终保持一个[pBegin,pEnd]的range,初始化确保[pBegin,pEnd]的ran
  • json数据解析及typeof chengxuyuancsdn jstypeofjson解析
    // json格式 var people='{"authors": [{"firstName": "AAA","lastName": "BBB"},' +' {"firstName": "CCC&
  • 流程系统设计的层次和目标 comsci 设计模式数据结构sql框架脚本
                                  流程系统设计的层次和目标  
  • RMAN List和report 命令 daizj oraclelistreportrman
    LIST 命令 使用RMAN LIST 命令显示有关资料档案库中记录的备份集、代理副本和映像副本的 信息。使用此命令可列出： • RMAN 资料档案库中状态不是AVAILABLE 的备份和副本 • 可用的且可以用于还原操作的数据文件备份和副本 • 备份集和副本，其中包含指定数据文件列表或指定表空间的备份 • 包含指定名称或范围的所有归档日志备份的备份集和副本 • 由标记、完成时间、可
  • 二叉树:红黑树 dieslrae 二叉树
        红黑树是一种自平衡的二叉树,它的查找,插入,删除操作时间复杂度皆为O(logN),不会出现普通二叉搜索树在最差情况时时间复杂度会变为O(N)的问题.     红黑树必须遵循红黑规则,规则如下     1、每个节点不是红就是黑。     2、根总是黑的  &
  • C语言homework3，7个小题目的代码 dcj3sjt126com c
    1、打印100以内的所有奇数。 # include <stdio.h> int main(void) { int i; for (i=1; i<=100; i++) { if (i%2 != 0) printf("%d ", i); } return 0; }  2、从键盘上输入10个整数，
  • 自定义按钮, 图片在上, 文字在下, 居中显示 dcj3sjt126com 自定义
    #import <UIKit/UIKit.h> @interface MyButton : UIButton -(void)setFrame:(CGRect)frame ImageName:(NSString*)imageName Target:(id)target Action:(SEL)action Title:(NSString*)title Font:(CGFloa
  • MySQL查询语句练习题，测试足够用了 flyvszhb sqlmysql
    http://blog.sina.com.cn/s/blog_767d65530101861c.html 1.创建student和score表 CREATE  TABLE  student ( id  INT(10)  NOT NULL  UNIQUE  PRIMARY KEY  , name  VARCHAR
  • 转：MyBatis Generator 详解 happyqing mybatis
      MyBatis Generator 详解 http://blog.csdn.net/isea533/article/details/42102297   MyBatis Generator详解 http://git.oschina.net/free/Mybatis_Utils/blob/master/MybatisGeneator/MybatisGeneator.
  • 让程序员少走弯路的14个忠告 jingjing0907 工作计划学习
      无论是谁，在刚进入某个领域之时，有再大的雄心壮志也敌不过眼前的迷茫：不知道应该怎么做，不知道应该做什么。下面是一名软件开发人员所学到的经验，希望能对大家有所帮助   1.不要害怕在工作中学习。 只要有电脑，就可以通过电子阅读器阅读报纸和大多数书籍。如果你只是做好自己的本职工作以及分配的任务，那是学不到很多东西的。如果你盲目地要求更多的工作，也是不可能提升自己的。放
  • nginx和NetScaler区别 流浪鱼 nginx
    NetScaler是一个完整的包含操作系统和应用交付功能的产品，Nginx并不包含操作系统，在处理连接方面，需要依赖于操作系统，所以在并发连接数方面和防DoS攻击方面，Nginx不具备优势。 2.易用性方面差别也比较大。Nginx对管理员的水平要求比较高，参数比较多，不确定性给运营带来隐患。在NetScaler常见的配置如健康检查，HA等，在Nginx上的配置的实现相对复杂。 3.策略灵活度方
  • 第11章 动画效果（下） onestopweb 动画
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • FAQ - SAP BW BO roadmap blueoxygen BOBW
    http://www.sdn.sap.com/irj/boc/business-objects-for-sap-faq   Besides, I care that how to integrate tightly.   By the way, for BW consultants, please just focus on Query Designer which i
  • 关于java堆内存溢出的几种情况 tomcat_oracle javajvmjdkthread
    【情况一】： 　　 java.lang.OutOfMemoryError: Java heap space：这种是java堆内存不够，一个原因是真不够，另一个原因是程序中有死循环； 　　如果是java堆内存不够的话，可以通过调整JVM下面的配置来解决： 　　<jvm-arg>-Xms3062m</jvm-arg> 　　<jvm-arg>-Xmx
  • Manifest.permission_group权限组 阿尔萨斯 Permission
    结构 继承关系 public static final class Manifest.permission_group extends Object java.lang.Object android. Manifest.permission_group 常量 ACCOUNTS 直接通过统计管理器访问管理的统计 COST_MONEY可以用来让用户花钱但不需要通过与他们直接牵涉的权限 D
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他