Java 常见面试问题整理 II

1
2
3
4
5
6
7
//接口（表示代理的目标接口）
public interface ICustomerService {
    //保存
    void save();
    //查询
    int find();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
//实现层
public class CustomerServiceImpl implements ICustomerService{
    @Override
    public void save() {
       System.out.println("客户保存了。。。。。");
    }

    @Override
    public int find() {
       System.out.println("客户查询数量了。。。。。");
       return 100;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//专门用来生成jdk的动态代理对象的-通用
public class JdkProxyFactory{
    //target目标对象
    private Object target;

    //注入target目标对象
    public JdkProxyFactory(Object target) {
       this.target = target;
    }

    public Object getProxyObject(){
        /**
         * 参数1：目标对象的类加载器
         * 参数2：目标对象实现的接口
         * 参数3：回调方法对象
        */
       return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), 
            new InvocationHandler(){
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    //如果是保存的方法，执行记录日志操作
                    if(method.getName().equals("save")){
                        System.out.println("增强代码：写日志了。。。");
                    }
                    //目标对象原来的方法执行
                    Object object = method.invoke(target, args);//调用目标对象的某个方法，并且返回目标对象
                    return object;
                 }
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//目标：使用动态代理，对原来的方法进行功能增强,而无需更改原来的代码。
//JDK动态代理：基于接口的（对象的类型，必须实现接口！）
@Test
public void testJdkProxy(){
   //target（目标对象）
   ICustomerService target = new CustomerServiceImpl();
   //实例化注入目标对象
   JdkProxyFactory jdkProxyFactory = new JdkProxyFactory(target);
   //获取 Object代理对象:基于目标对象类型的接口的类型的子类型的对象
   //必需使用接口对象去强转
   ICustomerService proxy = (ICustomerService)jdkProxyFactory.getProxyObject();
   //调用目标对象的方法
   proxy.save();
   System.out.println("————————————————————");
   proxy.find();
}

1
2
3
4
增强代码：写日志了。。。
客户保存了。。。。。
————————————————————
客户查询数量了。。。。。

1
2
3
4
5
6
7
8
9
10
11
//没有接口的类
public class ProductService {
    public void save() {
       System.out.println("商品保存了。。。。。");
    }

    public int find() {
       System.out.println("商品查询数量了。。。。。");
       return 99;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//cglib动态代理工厂:用来生成cglib代理对象
public class CglibProxyFactory implements MethodInterceptor{
    private Object target;

    //注入代理对象
    public CglibProxyFactory(Object target) {
       this.target = target;
    }

    //获取代理对象
    public Object getProxyObject(){
       //1.代理对象生成器(工厂思想)
       Enhancer enhancer = new Enhancer();
        // 类加载器
       enhancer.setClassLoader(target.getClass().getClassLoader());

       //2.在增强器上设置两个属性
       //设置要生成代理对象的目标对象：生成的目标对象类型的子类型
       enhancer.setSuperclass(target.getClass());
       //设置回调方法
       enhancer.setCallback(this);

       //3.创建获取对象
       return enhancer.create();
    }

    //回调方法（代理对象的方法）
    /**
     *  参数1：代理对象
     *  参数2：目标对象的方法对象
     *  参数3：目标对象的方法的参数的值
     *  参数4：代理对象的方法对象
     */
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
       //如果是保存的方法，执行记录日志操作
       if(method.getName().equals("save")){
            System.out.println("增强代码：写日志了。。。");
       }
        //目标对象原来的方法执行
        //调用目标对象的某个方法，并且返回目标对象
       Object object = method.invoke(target, args);
       return object;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//cglib动态代理：可以基于类（无需实现接口）生成代理对象
@Test
public void testCglibProxy(){
    //target目标：
    ProductService target = new ProductService();

    //代理工厂对象，注入目标
    CglibProxyFactory cglibProxyFactory = new CglibProxyFactory(target);

    //获取proxy
    //代理对象，其实是目标对象类型的子类型
    ProductService proxy = (ProductService)cglibProxyFactory.getProxyObject();
    //调用代理对象的方法
    proxy.save();
    System.out.println("—————————————————————");
    proxy.find();
}

1
2
3
4
增强代码：写日志了。。。
商品保存了。。。。。
————————————————————
商品查询数量了。。。。。

1
2
3
4
5
@Service
@Scope("singleton")
public class ServiceImpl {

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public class 面试题多线程输出 {
    private static volatile int num = 0; // 交替执行，一个输出偶数，一个输出奇数
    private static volatile boolean flag = false;
     public static void main(String[] args) {
        // 交替输出 0-100
        Thread_A a = new Thread_A();
        Thread_B b = new Thread_B();
        a.start();
        b.start();
    }

    /**
     * 交替输出 0-100
     */
    static class Thread_A extends Thread {
        @Override
        public void run() {
            for (; 100 > num; ) {
                if (!flag && (num == 0 || ++num % 2 == 0)) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {

                    }
                    System.out.println(this.getName() + "   " + num);
                    flag = true;
                }
            }
        }
    }

    /**
     * 交替输出 0-100
     */
    static class Thread_B extends Thread {
        @Override
        public void run() {
            for (; 100 > num; ) {
                if (flag && (++num % 2 != 0)) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {

                    }
                    System.out.println(this.getName() + "   " + num);
                    flag = false;
                }
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class 面试题多线程输出 {
    static volatile int a = 1;
    public static void main(String[] args) {
         // 交替输出 数字 和 字母
        Thread_C c = new Thread_C();
        Thread_D d = new Thread_D();
        c.start();
        d.start();
    }

    static class Thread_C extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 26; i++) {
                while (a % 2 == 1) {
                    try {
                        Thread.currentThread().interrupt();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                System.out.print(a / 2);
                a = a + 1;
            }
        }
    }

    static class Thread_D extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 26; i++) {
                while (a % 2 == 0) {
                    try {
                        Thread.currentThread().interrupt();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                System.out.print((char) ((a / 2) + 'A'));
                a = a + 1;
            }
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public abstract class TransactionSynchronizationManager {

	private static final Log logger = LogFactory.getLog(TransactionSynchronizationManager.class);

	private static final ThreadLocal<Map<Object, Object>> resources =
			new NamedThreadLocal<Map<Object, Object>>("Transactional resources");

	private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
			new NamedThreadLocal<Set<TransactionSynchronization>>("Transaction synchronizations");

	private static final ThreadLocal<String> currentTransactionName =
			new NamedThreadLocal<String>("Current transaction name");

	private static final ThreadLocal<Boolean> currentTransactionReadOnly =
			new NamedThreadLocal<Boolean>("Current transaction read-only status");

	private static final ThreadLocal<Integer> currentTransactionIsolationLevel =
			new NamedThreadLocal<Integer>("Current transaction isolation level");

	private static final ThreadLocal<Boolean> actualTransactionActive =
			new NamedThreadLocal<Boolean>("Actual transaction active");

            ...
            ...

}

1
2
3
4
5
6
7
8
9
10
11
public class UserThreadLocal {
    private static ThreadLocal<User> userHolder = new ThreadLocal<User>();

    public static void setUser(User user) {
        userHolder.set(user);
    }

    public static User getUser() {
        return userHolder.get();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Service
public class AccessInterceptor extends HandlerInterceptorAdapter {

    @Autowired
    UserService userService;

    @Autowired
    RedisService redisService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            User user = getUser(request, response);
            UserThreadLocal.setUser(user);
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            AccessLimit accessLimit = handlerMethod.getMethodAnnotation(AccessLimit.class);
            if (accessLimit == null) {
                return true;
            }
            ...
            ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Service
public class UserArgumentResolver implements HandlerMethodArgumentResolver {
     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        // 获取LoginInterceptor设置到request中的用户信息，注入到参数中
        User user = (User) webRequest.getAttribute("currentUser", RequestAttributes.SCOPE_REQUEST);
        if (user != null) {
            return user;
        } else {
            user = UserThreadLocal.getUser();
            if (user != null) {
                return user;
            }
        }
        throw new GlobalException(CodeMsg.SESSION_ERROR);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@Configuration
public class WebMvcConfig extends WebMvcConfigurerAdapter {
    @Autowired
    UserArgumentResolver userArgumentResolver;

    @Autowired
    AccessInterceptor accessInterceptor;

    /**
     * 往Controller的参数中赋值
     *
     * @param argumentResolvers
     */
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        argumentResolvers.add(userArgumentResolver);
    }

    /**
     * 将校验登录User是否为空的拦截器添加进来
     *
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 加入的顺序就是执行的顺序
        registry.addInterceptor(loginInterceptor).addPathPatterns("/**");
        registry.addInterceptor(accessInterceptor);
        super.addInterceptors(registry);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 /* ThreadLocal values pertaining to this thread. This map is maintained
  * by the ThreadLocal class. 
  */
ThreadLocal.ThreadLocalMap threadLocals = null;

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
static class ThreadLocalMap {

/**
* The entries in this hash map extend WeakReference, using
* its main ref field as the key (which is always a
* ThreadLocal object).  Note that null keys (i.e. entry.get()
* == null) mean that the key is no longer referenced, so the
* entry can be expunged from table.  Such entries are referred to
* as "stale entries" in the code that follows.
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

/**
* The initial capacity -- MUST be a power of two.
*/
private static final int INITIAL_CAPACITY = 16;

/**
* The table, resized as necessary.
* table.length MUST always be a power of two.
*/
private Entry[] table;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
private void set(ThreadLocal<?> key, Object value) {

    // We don't use a fast path as with get() because it is at
    // least as common to use set() to create new entries as
    // it is to replace existing ones, in which case, a fast
    // path would fail more often than not.
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

    for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();

        if (k == key) {
            e.value = value;
            return;
        }

        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

1
2
3
4
if (k == null) {
    replaceStaleEntry(key, value, i);
    return;
}

1
2
3
4
if (k == key) {
    e.value = value;
    return;
}

1
final ThreadLocal threadLocal = new InheritableThreadLocal();

1
2
3
4
5
6
7
ThreadLocal<String> localName = new ThreadLocal();
try {
    localName.set("张三");
    ……
} finally {
    localName.remove();
}

1
2
3
public interface Interface1 {
    void fun();
}

1
2
3
4
5
6
7
@Service("s1")
public class Interface1Impl1 implements Interface1 {
    @Override
    public void fun() {
        System.out.println("接口1实现类1 ...");
    }
}

1
2
3
4
5
6
7
@Service("s2")
public class Interface1Impl2 implements Interface1 {
    @Override
    public void fun() {
        System.out.println("接口1实现类2 ...");
    }
}

1
2
3
@Autowired
@Qualifier("s1")
private Interface1 interface1;

1
2
@Resource(name = "s1")
private Interface1 interface1;

1
2
3
4
5
6
7
8
9
10
11
@Service
@Primary
public class Interface1Impl1 implements Interface1 {
    @Override
    public void fun() {
        System.out.println("默认实现");
    }
}

@Autowired
private Interface1 interface1;