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
//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 = methodProxy.invokeSuper(proxy, 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
52
public class AlternateNumberPrinter {
    private int num = 0;
    private boolean oddTurn = false;

    public static void main(String[] args) {
        AlternateNumberPrinter printer = new AlternateNumberPrinter();
        Thread even = new Thread(printer::printEven, "even-thread");
        Thread odd = new Thread(printer::printOdd, "odd-thread");
        even.start();
        odd.start();
    }

    public synchronized void printEven() {
        while (num <= 100) {
            while (oddTurn) {
                waitSafely();
            }
            if (num > 100) {
                notifyAll();
                break;
            }
            System.out.println(Thread.currentThread().getName() + " " + num);
            num++;
            oddTurn = true;
            notifyAll();
        }
    }

    public synchronized void printOdd() {
        while (num <= 100) {
            while (!oddTurn) {
                waitSafely();
            }
            if (num > 100) {
                notifyAll();
                break;
            }
            System.out.println(Thread.currentThread().getName() + " " + num);
            num++;
            oddTurn = false;
            notifyAll();
        }
    }

    private void waitSafely() {
        try {
            wait();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

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 AlternateCharNumberPrinter {
    private int index = 0;
    private boolean charTurn = true;

    public static void main(String[] args) {
        AlternateCharNumberPrinter printer = new AlternateCharNumberPrinter();
        Thread charThread = new Thread(printer::printChar, "char-thread");
        Thread numberThread = new Thread(printer::printNumber, "number-thread");
        charThread.start();
        numberThread.start();
    }

    public synchronized void printChar() {
        while (index < 26) {
            while (!charTurn) {
                waitSafely();
            }
            if (index >= 26) {
                notifyAll();
                break;
            }
            System.out.print((char) ('A' + index));
            charTurn = false;
            notifyAll();
        }
    }

    public synchronized void printNumber() {
        while (index < 26) {
            while (charTurn) {
                waitSafely();
            }
            if (index >= 26) {
                notifyAll();
                break;
            }
            System.out.print(index + 1);
            index++;
            charTurn = true;
            notifyAll();
        }
    }

    private void waitSafely() {
        try {
            wait();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

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
12
13
14
15
public class UserThreadLocal {
    private static final ThreadLocal<User> userHolder = new ThreadLocal<>();

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

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

    public static void clear() {
        userHolder.remove();
    }
}

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
@Component
public class AccessInterceptor implements HandlerInterceptor {

    @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;
            }
            ...
            ...
        }
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        UserThreadLocal.clear();
    }
}

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
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @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(accessInterceptor);
    }
}

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;

1
2
@Autowired
private Map<String, Interface1> interface1Map;