xings

单例补充内部类方式

2017-01-22T00:00:00+00:00

使用内部类实现单例模式。

内部类单例模式

这种单例模式使用java类级内部类和多线程缺省同步锁。

类级内部类

是指由static修饰的内部类，没有static修饰的是对象级内部类。类级内部类相当于其外部类的成员，只有在第一次被使用时才会被装载。jvm对一个类的初始化会做限制，同一时间只会允许一个线程去初始化一个类，这样就从虚拟机层面避免多线程问题。

多线程缺省同步锁

是指在某些情况下，JVM隐含的执行了同步synchronized，如初始换静态数据时会进行同步控制。

单例模式-静态内部类

public class Singleton {
    private Singleton(){}

    public static Singleton getInstance(){
        return Nested.singleton;
    }
    
    static class Nested{
        private static Singleton singleton = new Singleton();
    }
}

Spring Bean对IoC容器的感知

2016-12-28T00:00:00+00:00

XXXAware在spring里表示XXX可感知。

Aware接口

Spring有许多Aware结尾接口，实现这些Aware接口的bean在被初始化之后，可以取得一些对应的资源。在初始化bean时，会检测是是否实现了这些接口并调用接口中的setter方法。

Aware接口	功能
BeanNameAware	可以在bean中得到它在IoC容器中的bean实例名称
BeanFactoryAware）	得到bean所在的IoC容器
ApplicationContentAware	得到bean所在的应用上下文
ApplicationEventPublisherAware	得到bean所在的应用上下文事件发布器
ServletConfigAware	web ServletConfig
ServletContextAware	web ServletContext
EnvironmentAware	web 环境
ResourceLoaderAware	资源加载器

ApplicationContentAware

ApplicationContentAware可以在bean中得到bean所在的应用上下文，从而直接在bean中使用应用上下文的服务。初始化bean时将applicationContent引用在bean中保存下来。

应用

public class SpringContext implements ApplicationContextAware{

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringContext.applicationContext = applicationContext;

    }

    public static <T> T getBean(String name) {
        return (T) applicationContext.getBean(name);
    }
}

同时在xml中将该类配置成bean

<bean class="com.springapp.mvc.common.util.SpringContext"></bean>

之后既可以在其他地方通过SpringContext.getBean("beanName")得到容器中的bean

EnvironmentAware

EnvironmentAware可以获得mvc下的web环境ServletContext、ServletConfig、系统环境变量、系统属性等都封装在其propertySource属性下。

@Controller
@RequestMapping("/webtest")
public class HelloController implements EnvironmentAware{

	private Environment environment;

	@Override
	public void setEnvironment(Environment environment) {
		this.environment = environment;
		String path = environment.getProperty("log4jConfigLocation");
	}
}

断点结果：

ASM——Java 字节码操控框架

2016-12-24T00:00:00+00:00

jdk中的proxy必须基于接口，封装了asm的cglib没有这种限制。

关于ASM

ASM是一个Java字节码操纵框架，它能被用来动态生成类或者增强既有类的功能。ASM可以直接产生二进制class文件，也可以在类被加载入Java虚拟机之前动态改变类行为。

AOP一种较好的实现方式就是修改class文件织入逻辑，cglib正是通过ASM实现动态代理。若想直接在字节码中增加内容，要对class文件结构和Java字节码有一定的了解，如方法和字段的描述符。(若要用复杂的逻辑需要ASM-Bytecode工具，会直接生成ASM代码)

标示字符	含义
B	基本类型byte
C	基本类型char
I	基本类型int
J	基本类型long
Z	基本类型boolean
V	特殊类型void
L	对象类型，如Ljava/lang/String

idea可以直接查看每个类的字节码。

demo

demo用ASM实现删除类中的方法、改变类中的方法、加入aop

原始的类:

public class SrcClass {
	//要删除的方法
    public void change1() {
        System.out.println("i am change-one!");
    }

    public void change2() {
        System.out.println("i am change-two");
    }
}

方法中要增加的逻辑

System.out.println("i am new");

要加载的aop方法

public class AopContent {

    public static void content(){
        System.out.println("i am aop");
    }
}

最后相当于要把SrcClass变成

public class SrcClass {
    public void change2() {
        System.out.println("i am new");
        System.out.println("i am aop");
        System.out.println("i am change-two");
    }
}

安插 Aop、删除方法和修改方法的ASM代码

public class AopMethodVisitor extends MethodVisitor implements Opcodes {

    public AopMethodVisitor(int i, MethodVisitor methodVisitor) {
        super(i, methodVisitor);
    }

    @Override
    public void visitCode() {
        super.visitCode();
        this.visitMethodInsn(INVOKESTATIC, "cn/qs/asm/AopContent", "content", "()V", false);
    }
}

class DemoVisitor extends ClassVisitor implements Opcodes {

    public DemoVisitor(int api, ClassVisitor cv) {
        super(api, cv);
    }

    @Override
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
        if (name.equals("change1")) {
            return null;
        }
        MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
        if (name.equals("change2")) {
            mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            mv.visitLdcInsn("i am new");
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V",false);
            return new AopMethodVisitor(this.api, mv);
        }
        return mv;
    }
}

ASM改写Java类

public class App extends ClassLoader implements Opcodes {
    public static void main(String[] args) throws IOException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, SecurityException, InstantiationException, InvocationTargetException, NoSuchMethodException {
        ClassReader cr=new ClassReader(SrcClass.class.getName());
        ClassWriter cw=new ClassWriter(ClassWriter.COMPUTE_MAXS);
        DemoVisitor myv=new DemoVisitor(Opcodes.ASM4,cw);
        cr.accept(myv, 0);

        byte[] code=cw.toByteArray();

        //自定义加载器
        App loader=new App();
        Class<?> appClass=loader.defineClass(null, code, 0,code.length);
        appClass.getMethods()[0].invoke(appClass.newInstance(), new Object[]{});
        Method[] methodArray = appClass.getMethods();
    }

最后输出结果：

 i am new
 i am aop
 i am change-two

同时查看methodArray中已经没有方法change1

Spring mvc自定义全局异常处理

2016-12-18T00:00:00+00:00

springmvc提供全局异常处理器进行统一异常处理

全局异常

spring mvc可以通过实现HandlerExceptionResolver接口自定义异常。HandlerExceptionResolver中仅有一个方法

	ModelAndView resolveException(
				HttpServletRequest request, HttpServletResponse 	response, Object handler, Exception ex);

使用方法

自定义全局异常方法

继承HandlerExceptionResolver并实现其方法

public class GlobalExceptionResolver implements HandlerExceptionResolver {

    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        String accept = request.getHeader("Content-Type");
        if (null != accept && accept.indexOf("application/json") <= -1) {
            StringBuilder detail = new StringBuilder();
            ModelAndView exceptionView = new ModelAndView("error");
            if (ex != null) {
                StackTraceElement[] arr = ex.getStackTrace();
                int len = arr.length;
                for (int i = 0; i < len; ++i) {
                    StackTraceElement element = arr[i];
                    detail.append(element.toString().replace("\t", "").replace("\n", "").replace("\r", ""));
                }
                exceptionView.addObject("stackInfo", detail.toString());
            }
            exceptionView.addObject("errorMsg", ex.getMessage());
            return exceptionView;
        } else {
            ServiceResponseBase exceptionEntity = new ServiceResponseBase();
            exceptionEntity.setRetcode(-1);
            exceptionEntity.setRetdesc(ex.getMessage());
            String exceptionEntityJson = JSON.toJSONString(exceptionEntity);
            ModelAndView exceptionView = new ModelAndView("apierror");
            exceptionView.addObject("errorResponse", exceptionEntityJson);
            return exceptionView;
        }
    }
}

在mvc配置文件中配置全局异常处理器

<bean id="exceptionResolver"
          class="com.springapp.mvc.exception.GlobalExceptionResolver">
</bean>

在视图中解析异常信息

error.vm

${errorMsg}
${stackInfo}

apierror.vm

${errorResponse}

示例

	@RequestMapping(value = "/testPage")
	@ResponseBody
	public  String test1(){
		int a = 1/0;
		return "ok";
	}

返回结果：

Json请求

其他请求

Mybatis逆向工程

2016-12-17T00:00:00+00:00

mybatis官方提供逆向工程可以针对单表自动生成mybatis执行所需要的代码

逆向工程

MyBatis Generator(MBG)，可以逆向生成持久层的基本代码，可以自由组合完成比较复杂的查询，maven依赖 MyBatis Generator Core。

官方文档

使用方法

修改配置文件

配置逆向工程配置文件 genreatorConfig.xml，（官方配置说明），主要配置以下几处

数据库连接信息
指定生成文件存放的路径
指定数据库中表

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
	<context id="testTables" targetRuntime="MyBatis3">
		<commentGenerator>
			<!-- 是否去除自动生成的注释 true：是 ： false:否 -->
			<property name="suppressAllComments" value="true" />
		</commentGenerator>
		<!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
		<jdbcConnection driverClass="com.mysql.jdbc.Driver"
			connectionURL="jdbc:mysql://localhost:3306/testdb"
						userId="root"
			password="123456">
		</jdbcConnection>
		<!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL 和 
			NUMERIC 类型解析为java.math.BigDecimal -->
		<javaTypeResolver>
			<property name="forceBigDecimals" value="false" />
		</javaTypeResolver>

		<!-- targetProject:生成PO类的位置 -->
		<javaModelGenerator targetPackage="cn.qs.model"
			targetProject="src/main/java">
			<!-- enableSubPackages:是否让schema作为包的后缀 -->
			<property name="enableSubPackages" value="false" />
			<!-- 从数据库返回的值被清理前后的空格 -->
			<property name="trimStrings" value="true" />
		</javaModelGenerator>
        <!-- targetProject:mapper映射文件生成的位置 -->
		<sqlMapGenerator targetPackage="cn.qs.mapper"
			targetProject="src/main/java">
			<!-- enableSubPackages:是否让schema作为包的后缀 -->
			<property name="enableSubPackages" value="false" />
		</sqlMapGenerator>
		<!-- targetPackage：mapper接口生成的位置 -->
		<javaClientGenerator type="XMLMAPPER"
			targetPackage="cn.qs.mapper"
			targetProject="src/main/java">
			<!-- enableSubPackages:是否让schema作为包的后缀 -->
			<property name="enableSubPackages" value="false" />
		</javaClientGenerator>
		<!-- 指定数据库表 -->
		<table tableName="qqvip_card_data"></table>
		<table tableName="qqvip_card_config"></table>

	</context>
</generatorConfiguration>

运行java生成程序

生成 mapper.java、mapper.xml、Example.java、po等文件。

public class GeneratorSqlmap {

	public void generator() throws Exception{

		List<String> warnings = new ArrayList<String>();
		boolean overwrite = true;
		//指定 逆向工程配置文件
		String genConfig = "conf/core/generatorConfig.xml";
		ClassLoader classLoader = getClass().getClassLoader();
		File configFile = new File(classLoader.getResource(genConfig).getFile());
		ConfigurationParser cp = new ConfigurationParser(warnings);
		Configuration config = cp.parseConfiguration(configFile);
		DefaultShellCallback callback = new DefaultShellCallback(overwrite);
		MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
				callback, warnings);
		myBatisGenerator.generate(null);

	} 
	public static void main(String[] args) throws Exception {
		try {
			GeneratorSqlmap generatorSqlmap = new GeneratorSqlmap();
			generatorSqlmap.generator();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

}

使用生成的文件

示例

genreatorConfig.xml文件配置

java代码生成

具体示例参见 github: mybatis-generator

Java并发编程：阻塞队列

2016-11-29T00:00:00+00:00

生产消费模型首选的数据结构。

Queue

一种先进先出（FIFO）的数据结构。

阻塞队列

BlockingQueue在Queue基础上添加的接口：

take：如果队列为空，则阻塞
put ：如果队列满，则阻塞
offer(E e, long timeout, TimeUnit unit) ：队列满时可以指定阻塞时间，若不指定则返回false
poll(long timeout, TimeUnit unit)：队列空时介意指定阻塞时间，不指定返回null

常用阻塞队列

ArrayBlockingQueue：有界，构造时要指定大小
LinkedBlockingQueue：创建时可以不指定大小
PriorityBlockingQueue：队列中元素要是实现Comparable接口，take时先出优先级高的
DelayQueue：队列元素实现Delayed接口，头是存活时间最长元素

实现原理

判断数组是否为空或已满&&线程间通信

MultiValueMap——一个key对应多个value

2016-11-21T00:00:00+00:00

在实际应用中往往需要一个key对应多个value的情况，介绍几个第三方的api实现。

guava Multimap

package com.google.common.collect;

 ListMultimap<String,String> multiMap = ArrayListMultimap.create();
 multiMap.put("a","b");
 multiMap.put("a", "c");
 List<String> value = multiMap.get("a");

对集合的扩充和增强，无论从简洁、易读和易维护等方面，gauva都是首选的。

apache MultiValueMap

 MultiValueMap  multiValueMap = new MultiValueMap();
 multiValueMap.put("a","b");
 multiValueMap.put("a", "c");
 Collection a =multiValueMap.getCollection("a");

Spring MultiValueMap

最后是spring同样提供了MultiValueMap的一些基础操作，位于package org.springframework.util

 MultiValueMap<String,String> multiValueMap = new LinkedMultiValueMap();
 multiValueMap.add("a","b");
 multiValueMap.add("a", "c");
 List<String> value = multiValueMap.get("a");

spring的实现最简单，通过封装Map<K, List<V>> map结构

截取的部分源码

Proxy代理模式

2016-04-27T00:00:00+00:00

代理模式为其他对象提供一种代理以控制对这个对象的访问。

代理模式

为其他对象提供一种代理以控制对这个对象的访问

让代理对象控制目标对象的访问，添加一些额外的功能。

静态代理

模式结构：三种角色

抽象角色：真实对象和代理对象的共同接口
真实角色：代理角色所代表的真实对象
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时，代理对象在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

//抽象角色Subject
public interface Subject {
	public void doSomething();
}

//真实角色RealSubject
public class RealSubject implements Subject {

	public void doSomething(){
		System.out.println("一些操作");
	}
}

//代理角色ProxySubject
public class ProxySubject implements Subject {

	RealSubject realSubject = new RealSubject();
	
	public void doSomething(){
		System.out.println("操作前**********");
		realSubject.doSomething();
		System.out.println("操作后**********");
	}
}

public class TestProxy  {

    public static void main(String[] args) {
    
        Subject proxy = new ProxySubject();
        proxy.doSomething()
    }
}

输出结果

操作前**********
一些操作
操作后**********

动态代理

动态代理类的字节码在程序运行时由Java反射机制动态生成

JDK动态代理

Java动态代理类位于Java.lang.reflect包下，一般主要涉及一个类和一个接口：

InvocationHandler接口 (java.lang.reflect.InvocationHandler)
Proxy类 (java.lang.reflect.Proxy)

//抽象角色Subject
public interface Subject {
	public void doSomething();
}

//真实角色RealSubject
public class RealSubject implements Subject {

	public void doSomething(){
		System.out.println("一些操作");
	}
}

//代理角色ProxySubject
public class ProxySubject implements InvocationHandler {  
    private Object target;
	public Object getProxy(Object target) {  
        this.target = target;  
        //取得代理对象  
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
                target.getClass().getInterfaces(), this);   
     //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷) 
    }  
    
    @Override  
    public Object invoke(Object proxy, Method method, Object[] args)  
        Object result=null;  
        System.out.println("操作前**********");
        result=method.invoke(target, args);  
        System.out.println("操作后**********");  
        return result;  
    }

public class TestProxy {  
  
    public static void main(String[] args) {  
        ProxySubject ProxySubject = new ProxySubject();  
        Subject proxy = (Subject) ProxySubject.getProxy(new RealSubject());  
        proxy.doSomething();  
    }  
  
}

输出结果

操作前**********
一些操作
操作后**********

JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了

cglib动态代理

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强。

//真实角色RealSubject
public class RealSubject implements Subject {

	public void doSomething(){
		System.out.println("一些操作");
	}
}

public class ProxySubject implements MethodInterceptor {  
    private Object target;
    public Object getProxy(Object target) {  
    
	    this.target = target;  
        Enhancer enhancer = new Enhancer();  
        enhancer.setSuperclass(this.target.getClass());  
        // 回调方法  
        enhancer.setCallback(this);  
        // 创建代理对象  
        return enhancer.create();  
    }  
    
    @Override  
    // 回调方法  
    public Object intercept(Object obj, Method method, Object[] args,MethodProxy proxy) {  
	    System.out.println("操作前**********");  
        proxy.invokeSuper(obj, args);  
        System.out.println("操作后**********");  
        return null;

public class TestProxy {  
  
    public static void main(String[] args) {  
        ProxySubject ProxySubject = new ProxySubject();  
        RealSubject proxy = (RealSubject) ProxySubject.getProxy(new RealSubject());  
        proxy.doSomething();  
    }  
  
}

输出结果

操作前**********
一些操作
操作后**********

静态代理和动态代理区别

静态代理：由程序员或者自动生成工具生成代理类，然后进行代理类的编译和运行。在代理类、委托类运行之前，代理类已经以.class的格式存在。

动态代理：在程序运行时，由反射机制动态创建而成。

cglib和jdk代理区别

JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

cglib动态代理：利用asm开源包（java字节码操纵框架），对代理对象类的class文件加载进来，通过修改其字节码生成子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。

JDK动态代理：利用用传入的接口创建一个匿名类，在该类中织入横切逻辑。

Map的遍历

2016-03-04T00:00:00+00:00

4种遍历map的方法。

通过map.keySet遍历

Map<String,String> map = new HashMap<String,String>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");

        for(String key : map.keySet()) {
            String value = map.get(key);
            System.out.println(value);
        }

通过map.entrySet遍历

Map<String, String> map = new HashMap<String, String>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");

        for (Map.Entry<String, String> entry : map.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(value);
        }

通过map.values()

Map<String, String> map = new HashMap<String, String>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");

        for (String v : map.values()) {
            String value = v;
            System.out.println(value);
        }

通过Map.entrySet迭代器

只和第二种遍历Map.entrySet的方式不同

Map<String, String> map = new HashMap<String, String>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");

        Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
        while (it.hasNext()) {
            String value = it.next().getValue();
            System.out.println(value);
        }

Java反射机制

2016-03-01T00:00:00+00:00

反射机制动态地获取类的一切信息，并可以用这些信息做一些想做的事情。

反射机制

所谓反射，是指在运行时状态中，获取类中的属性和方法，以及调用其中的方法的一种机制。这种机制的作用在于获取运行时才知道的类（Class）及其中的属性（Field）、方法（Method）以及调用其中的方法，也可以设置其中的属性值。

Class文件由类装载器装载后，在JVM中将形成一份描述Class结构的元信息对象，通过该元信息对象可以获知Class的结构信息：如构造函数、属性和方法等。Java允许用户借由这个Class相关的元信息对象间接调用Class对象的功能。

Class类

java.lang.Class类十分特殊，用来表示java中类型本身。 Class类是Reflection的根源。针对任何想动态加载、运行的类，唯有先获得相应的Class 对象。一个类被加载后，JVM会创建一个对应该类的Class对象，类的整个结构信息会放到对应的Class对象中。

Java中获取class类的对象有如下几种方式：

通过Class.forName()(最常用)
通过.class 语法
运用getClass()

例如：

String path = "com.test.bean.User";
Class clazz1 = Class.forName(path);
          
Class strClazz = String.class;
Class intClazz =int.class;
  
Class strClazz2 = path.getClass();

应用反射API

通过反射机制访问java对象的属性，方法，构造方法 sun提供了反射机制中的类

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

获取类的信息(类的名字、属性、方法、构造器等)

有如下javabean：

package com.test.bean;
public class User {
     
    private int id;
    private int age;
    private String name;
     
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    //必须要有无参的构造方法，否则构造对象的时候要先拿到有参数的构造方法，然后赋予参数再构建对象。
    public User() { }
    public User(int id,int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
}

获取类的信息demo

public class Demo02 {
    public static void main(String[] args) throws NoSuchFieldException, ClassNotFoundException, NoSuchMethodException {
        String path = "com.test.bean.User";
        Class clazz = Class.forName(path);
        //获取类的名字
        System.out.println(clazz.getName());//获得包名+类名：com.test.bean.User
        System.out.println(clazz.getSimpleName());  //获的类名：User

        //获取属性信息
        //Field[] fields = clazz.getFields(); //只能获得public的field
        Field[] fields = clazz.getDeclaredFields();//获得所有的field
        Field f = clazz.getDeclaredField("name");
        System.out.println(fields.length);
        for (Field temp : fields) {
            System.out.println("属性：" + temp);
        }
        //获取方法信息
        Method[] methods = clazz.getDeclaredMethods();
        Method m01 = clazz.getDeclaredMethod("getName", null);
        //如果方法有参，则必须传递参数类型对应的class对象(有重载时可区分)
        Method m02 = clazz.getDeclaredMethod("setName", String.class);
        for (Method m : methods) {
            System.out.println("方法：" + m);
        }

        //获得构造器信息
        Constructor[] constructors = clazz.getDeclaredConstructors();
        //Constructor c = clazz.getDeclaredConstructor(int.class,int.class,String.class);
        //System.out.println("获得构造器："+c);
        for (Constructor temp : constructors) {
            System.out.println("构造器：" + temp);
        }
    }
}

输出结果：

com.test.bean.User
User
3
属性：private int cn.qs.reflect.User.id
属性：private int cn.qs.reflect.User.age
属性：private java.lang.String cn.qs.reflect.User.name
方法：public java.lang.String cn.qs.reflect.User.getName()
方法：public void cn.qs.reflect.User.setName(java.lang.String)
方法：public int cn.qs.reflect.User.getId()
方法：public void cn.qs.reflect.User.setId(int)
方法：public int cn.qs.reflect.User.getAge()
方法：public void cn.qs.reflect.User.setAge(int)
构造器：public cn.qs.reflect.User(int,int,java.lang.String)
构造器：public cn.qs.reflect.User()

动态的操作：构造器、方法、属性

public class Demo03 {
    public static void main(String[] args) {
		String path = "com.test.bean.User";
		Class<User> clazz = (Class<User>) Class.forName(path);
		//通过反射API调用构造方法，构造对象
		User u = clazz.newInstance();   //其实是调用了User的无参构造方法
		System.out.println(u);
		Constructor<User> c = clazz.getDeclaredConstructor(int.class,int.class,String.class);
		User u2 = c.newInstance(1001,18,"Tim");
		System.out.println(u2.getName());

		//通过反射API调用普通方法
		User u3 = clazz.newInstance();
		Method method = clazz.getDeclaredMethod("setUname", String.class);
		method.invoke(u3, "tom");   //u3.setUname("tom");
		System.out.println(u3.getUname());

		//通过反射API操作属性
		User u4 = clazz.newInstance();
		Field f = clazz.getDeclaredField("uname");
		f.setAccessible(true); //这个属性不需要做安全检查了，可以直接访问
		f.set(u4, "Amay");       //通过反射直接写属性
		System.out.println(u4.getUname());  //通过反射直接读属性的值
		System.out.println(f.get(u4));
	}
}

输出结果：

com.test.bean.User@723279cf
Tim
tom
Amay
Amay

反射性能问题

setAccessible

启用和禁用访问安全检查的开关，值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。值为 false 则指示反射的对象应该实施 Java 语言访问检查。禁止安全检查，可以提高反射的运行速度。

public class Demo03 {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException, ClassNotFoundException {
        String path = "com.test.bean.User";
        Class<User> clazz = (Class<User>) Class.forName(path);
        //通过反射API调用构造方法，构造对象
        User u = clazz.newInstance();   //其实是调用了User的无参构造方法
        System.out.println(u);
        Constructor<User> c = clazz.getDeclaredConstructor(int.class, int.class, String.class);
        User u2 = c.newInstance(1001, 18, "Tim");
        System.out.println(u2.getName());

        //通过反射API调用普通方法
        User u3 = clazz.newInstance();
        Method method = clazz.getDeclaredMethod("setName", String.class);
        method.invoke(u3, "tom");   //u3.setUname("tom");
        System.out.println(u3.getName());

        //通过反射API操作属性
        User u4 = clazz.newInstance();
        Field f = clazz.getDeclaredField("name");
        f.setAccessible(true); //这个属性不需要做安全检查了，可以直接访问
        f.set(u4, "Amay");       //通过反射直接写属性
        System.out.println(u4.getName());  //通过反射直接读属性的值
        System.out.println(f.get(u4));
    }
}

执行结果：

普通方法调用，执行10亿次，耗时：2218ms
反射动态方法调用，执行10亿次，耗时：63427ms
反射动态方法调用，跳过安全检查，执行10亿次，耗时：14335ms

显然，通过测试发现反射比普通方法调用效率大大降低，但是可以通过禁止访问安全检查提高效率。万事都有利弊，反射降低了运行效率，但是灵活性提高了开发效率。

xings

单例补充 内部类方式

内部类单例模式

类级内部类

多线程缺省同步锁

单例模式-静态内部类

Spring Bean对IoC容器的感知

Aware接口

ApplicationContentAware

应用

EnvironmentAware

ASM——Java 字节码操控框架

关于ASM

demo

原始的类:

方法中要增加的逻辑

要加载的aop方法

安插 Aop、删除方法和修改方法的ASM代码

ASM改写Java类

Spring mvc自定义全局异常处理

全局异常

使用方法

自定义全局异常方法

在mvc配置文件中配置全局异常处理器

在视图中解析异常信息

示例

Mybatis逆向工程

逆向工程

使用方法

修改配置文件

运行java生成程序

示例

Java并发编程：阻塞队列

Queue

阻塞队列

常用阻塞队列

实现原理

MultiValueMap——一个key对应多个value

guava Multimap

apache MultiValueMap

Spring MultiValueMap

Proxy代理模式

代理模式

静态代理

动态代理

JDK动态代理

cglib动态代理

静态代理和动态代理区别

cglib和jdk代理区别

Map的遍历

通过map.keySet遍历

通过map.entrySet遍历

通过map.values()

通过Map.entrySet迭代器

Java反射机制

反射机制

Class类

应用反射API

获取类的信息(类的名字、属性、方法、构造器等)

动态的操作：构造器、方法、属性

反射性能问题

单例补充内部类方式