广西快3开奖时间开奖:ImportNew - ★广西快3龙虎★ //www.klh31.com Tue, 09 Apr 2019 13:03:29 +0000 zh-CN hourly 1 //wordpress.org/?v=3.4.2 Spring AOP是什么?你都拿它做什么? - ★广西快3龙虎★ //www.klh31.com/31318.html //www.klh31.com/31318.html#comments Sat, 12 Jan 2019 12:40:05 +0000 唐尤华 //www.klh31.com/?p=31318 为什么会有面向切面编程(AOP)?我们知道Java是一个面向对象(OOP)的语言,但它有一些弊端,比如当我们需要为多个不具有继承关系的对象引入一个公共行为,例如日志、权限验证、事务等功能时,只能在在每个对象里引用公共行为。这样做不便于维护,而且有大量重复代码。AOP的出现弥补了OOP的这点不足。

为了阐述清楚Spring AOP,我们从将以下方面进行讨论:

  1. 代理模式
  2. 静态代理原理及实践
  3. 动态代理原理及实践
  4. Spring AOP原理及实战

1. 代理模式

代理模式:为其他对象提供一种代理以控制对这个对象的访问。这段话比较官方,但我更倾向于用自己的语言理解:比如A对象要做一件事情,在没有代理前,自己来做;在对 A 代理后,由 A 的代理类 B 来做。代理其实是在原实例前后加了一层处理,这也是 AOP 的初级轮廓。

2. 静态代理原理及实践

静态代理模式:静态代理说白了,就是在程序运行前就已经存在代理类的字节码文件、代理类和原始类的关系在运行前就已经确定。废话不多说,我们看一下代码。为了方便阅读,博主把单独的 class 文件合并到接口中,读者可以直接复制代码运行:

package test.staticProxy;

// 接口
public interface IUserDao {
    void save();
    void find();
}

//目标对象
class UserDao implements IUserDao{
    @Override
    public void save() {
        System.out.println("模拟:保存用户!");
    }
    @Override
    public void find() {
        System.out.println("模拟:查询用户");
    }
}

/**
  * 静态代理
  * 特点:
  * 2. 目标对象必须要实现接口
  * 2. 代理对象,要实现与目标对象一样的接口
 */
class UserDaoProxy implements IUserDao{

    // 代理对象,需要维护一个目标对象
    private IUserDao target = new UserDao();

    @Override
    public void save() {
        System.out.println("代理操作: 开启事务...");
        target.save();   // 执行目标对象的方法
        System.out.println("代理操作:提交事务...");
    }

    @Override
    public void find() {
        target.find();
    }
}

测试结果:

静态代理虽然保证了业务类只需关注逻辑本身,代理对象的一个接口只服务于一种类型的对象。如果要代理的方法很多,势必要为每一种方法都进行代理。再者,如果增加一个方法,除了实现类需要实现这个方法外,所有的代理类也要实现此方法。增加了代码的维护成本。那么要如何解决呢?答案是使用动态代理。

3. 动态代理原理及实践

动态代理模式:动态代理类的源码是在程序运行期间,通过 JVM 反射等机制动态生成。代理类和委托类的关系是运行时才确定的。实例如下:

package test.dynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 接口
public interface IUserDao {
    void save();
    void find();
}

//目标对象
class UserDao implements IUserDao{

    @Override
    public void save() {
        System.out.println("模拟: 保存用户!");
    }

    @Override
    public void find() {
        System.out.println("查询");
    }
}

/**
 * 动态代理:
 * 代理工厂,给多个目标对象生成代理对象!
 *
 */
class ProxyFactory {

    // 接收一个目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    // 返回对目标对象(target)代理后的对象(proxy)
    public Object getProxyInstance() {
        Object proxy = Proxy.newProxyInstance(
            target.getClass().getClassLoader(),  // 目标对象使用的类加载器
            target.getClass().getInterfaces(),   // 目标对象实现的所有接口
            new InvocationHandler() {            // 执行代理对象方法时候触发

                @Override
                public Object invoke(Object proxy, Method method, Object[] args)
                        throws Throwable {

                    // 获取当前执行的方法的方法名
                    String methodName = method.getName();
                    // 方法返回值
                    Object result = null;
                    if ("find".equals(methodName)) {
                        // 直接调用目标对象方法
                        result = method.invoke(target, args);
                    } else {
                        System.out.println("开启事务...");
                        // 执行目标对象方法
                        result = method.invoke(target, args);
                        System.out.println("提交事务...");
                    }
                    return result;
                }
            }
        );
        return proxy;
    }
}

测试结果如下:

IUserDao proxy = (IUserDao)new ProxyFactory(target).getProxyInstance();

其实是 JDK 动态生成了一个类去实现接口,隐藏了这个过程:

class $jdkProxy implements IUserDao{}

使用 JDK 生成的动态代理的前提是目标类必须有实现的接口。但这里又引入一个问题,如果某个类没有实现接口,就不能使用 JDK 动态代理。所以 CGLIB 代理就是解决这个问题的。

CGLIB?是以动态生成的子类继承目标的方式实现,在运行期动态的在内存中构建一个子类,如下:

public class UserDao{}

// CGLIB 是以动态生成的子类继承目标的方式实现,程序执行时,隐藏了下面的过程
public class $Cglib_Proxy_class  extends UserDao{}

CGLIB 使用的前提是目标类不能为 final 修饰。因为 final 修饰的类不能被继承。

现在,我们可以看看 AOP 的定义:面向切面编程,核心原理是使用动态代理模式在方法执行前后或出现异常时加入相关逻辑。

通过定义和前面代码我们可以发现3点:

  • AOP 是基于动态代理模式。
  • AOP 是方法级别的。
  • AOP 可以分离业务代码和关注点代码(重复代码),在执行业务代码时,动态的注入关注点代码。切面就是关注点代码形成的类。

4. Spring AOP

前文提到 JDK 代理和 CGLIB 代理两种动态代理。优秀的 Spring 框架把两种方式在底层都集成了进去,我们无需担心自己去实现动态生成代理。那么,Spring是如何生成代理对象的?

  1. 创建容器对象的时候,根据切入点表达式拦截的类,生成代理对象。
  2. 如果目标对象有实现接口,使用 JDK 代理。如果目标对象没有实现接口,则使用 CGLIB 代理。然后从容器获取代理后的对象,在运行期植入“切面”类的方法。通过查看 Spring 源码,我们在 DefaultAopProxyFactory 类中,找到这样一段话。

简单的从字面意思看出:如果有接口,则使用 JDK 代理,反之使用 CGLIB ,这刚好印证了前文所阐述的内容。Spring AOP 综合两种代理方式的使用前提有会如下结论:如果目标类没有实现接口,且 class 为 final 修饰的,则不能进行 Spring AOP 编程!

知道了原理,现在我们将自己手动实现 Spring 的 AOP:

package test.spring_aop_anno;

import org.aspectj.lang.ProceedingJoinPoint;

public interface IUserDao {
    void save();
}

// 用于测试 CGLIB 动态代理
class OrderDao {
    public void save() {
        //int i =1/0; 用于测试异常通知
        System.out.println("保存订单...");
    }
}

//用于测试 JDK 动态代理
class UserDao implements IUserDao {
    public void save() {
        //int i =1/0; 用于测试异常通知
        System.out.println("保存用户...");
    }
}

//切面类
class TransactionAop {

    public void beginTransaction() {
        System.out.println("[前置通知]  开启事务..");
    }

    public void commit() {
        System.out.println("[后置通知] 提交事务..");
    }

    public void afterReturing() {
        System.out.println("[返回后通知]");
    }

    public void afterThrowing() {
        System.out.println("[异常通知]");
    }

    public void arroud(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("[环绕前:]");
        pjp.proceed(); // 执行目标方法
        System.out.println("[环绕后:]");
    }
}

Spring 的 XML 配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="//www.springframework.org/schema/beans"
    xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
    xmlns:context="//www.springframework.org/schema/context"
    xmlns:aop="//www.springframework.org/schema/aop"
    xsi:schemaLocation="

//www.springframework.org/schema/beans


//www.springframework.org/schema/beans/spring-beans.xsd


//www.springframework.org/schema/context


//www.springframework.org/schema/context/spring-context.xsd


//www.springframework.org/schema/aop


//www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- dao实例加入容器 -->
    <bean id="userDao" class="test.spring_aop_anno.UserDao"></bean>

    <!-- dao实例加入容器 -->
    <bean id="orderDao" class="test.spring_aop_anno.OrderDao"></bean>

    <!-- 实例化切面类 -->
    <bean id="transactionAop" class="test.spring_aop_anno.TransactionAop"></bean>

    <!-- Aop相关配置 -->
    <aop:config>
        <!-- 切入点表达式定义 -->
        <aop:pointcut expression="execution(* test.spring_aop_anno.*Dao.*(..))" id="transactionPointcut"/>
        <!-- 切面配置 -->
        <aop:aspect ref="transactionAop">
            <!-- 【环绕通知】 -->
            <aop:around method="arroud" pointcut-ref="transactionPointcut"/>
            <!-- 【前置通知】 在目标方法之前执行 -->
            <aop:before method="beginTransaction" pointcut-ref="transactionPointcut" />
            <!-- 【后置通知】 -->
            <aop:after method="commit" pointcut-ref="transactionPointcut"/>
            <!-- 【返回后通知】 -->
            <aop:after-returning method="afterReturing" pointcut-ref="transactionPointcut"/>
            <!-- 异常通知 -->
            <aop:after-throwing method="afterThrowing" pointcut-ref="transactionPointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

切入点表达式不在这里介绍。参考?Spring AOP 切入点表达式

代码的测试结果如下:

到这里,我们已经全部介绍完Spring AOP?;氐娇奈侍?,我们拿它做什么?

  1. Spring声明式事务管理配置:请参考博主的另一篇文章:分布式系统架构实战 demo:SSM+Dubbo
  2. Controller层的参数校验:参考 Spring AOP拦截Controller做参数校验
  3. 使用 Spring AOP 实现 MySQL 数据库读写分离案例分析
  4. 在执行方法前,判断是否具有权限
  5. 对部分函数的调用进行日志记录:监控部分重要函数,若抛出指定的异常,可以以短信或邮件方式通知相关人员。
  6. 信息过滤,页面转发等等功能

博主一个人的力量有限,只能列举这么多,欢迎评论区对文章做补充。

Spring AOP还能做什么,实现什么魔幻功能,就在于我们每一个平凡而又睿智的程序猿!

相关文章

]]>
//www.klh31.com/31318.html/feed 5
一文搞清Gradle依赖 - ★广西快3龙虎★ //www.klh31.com/31297.html //www.klh31.com/31297.html#comments Thu, 10 Jan 2019 17:42:18 +0000 唐尤华 //www.klh31.com/?p=31297

之前对 Android Gradle 构建的依赖一直傻傻分不清,这段时间正好接入集团的一个二方库,踩了很多坑,也顺带把 Gradle 依赖这块搞清楚了,主要整理了下 Gradle 依赖的类型、依赖配置、如何查看依赖、依赖冲突如何解决。

依赖类型

dependencies DSL 标签是标准 Gradle API 中的一部分,而不是 Android Gradle 插件的特性,所以它不属于 Android 标签。
依赖有三种方式,如下面的例子:

apply plugin: 'com.android.application'

android { ... }

dependencies {
    // Dependency on a local library module
    implementation project(":mylibrary")

    // Dependency on local binaries
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    // Dependency on a remote binary
    implementation 'com.example.android:app-magic:12.3'
}

本地 library ??橐览?/strong>

implementation project(":mylibrary")

这种依赖方式是直接依赖本地库工程代码的(需要注意的是,mylibrary 的名字必须匹配在 settings.gradle 中 include 标签下定义的??槊郑?。

本地二进制依赖

implementation fileTree(dir: 'libs', include: ['*.jar'])

这种依赖方式是依赖工程中的 module_name/libs/ 目录下的 Jar 文件(注意 Gradle 的路径是相对于 build.gradle 文件来读取的,所以上面是这样的相对路径)。

如果只想依赖单个特定本地二进制库,可以如下配置:

implementation files('libs/foo.jar', 'libs/bar.jar')

远程二进制依赖

implementation 'com.example.android:app-magic:12.3'

上面是简写的方式,这种依赖完整的写法如下:

implementation group: 'com.example.android', name: 'app-magic', version: '12.3'

group、name、version共同定位一个远程依赖库。需要注意的点是,version最好不要写成”12.3+”这种方式,除非有明确的预期,因为非预期的版本更新会带来构建问题。远程依赖需要在repositories标签下声明远程仓库,例如jcenter()、google()、maven仓库等。

依赖配置

目前 Gradle 版本支持的依赖配置有:implementation、api、compileOnly、runtimeOnly 和 annotationProcessor。已经废弃的配置有:compile、provided、apk、providedCompile。此外依赖配置还可以加一些配置项,例如 AndroidTestImplementation、debugApi 等等。

常用的是 implementation、api、compileOnly 三个依赖配置,含义如下:

  • implementation:与compile对应,会添加依赖到编译路径,并且会将依赖打包到输出(aar或apk),但是在编译时不会将依赖的实现暴露给其他module,也就是只有在运行时其他module才能访问这个依赖中的实现。使用这个配置,可以显著提升构建时间,因为它可以减少重新编译的module的数量。建议,尽量使用这个依赖配置。
  • api:与 compile 对应,功能完全一样,会添加依赖到编译路径,并且会将依赖打包到输出(aar 或a pk)。与 implementation 不同,这个依赖可以传递,其他 module 无论在编译时和运行时都可以访问这个依赖的实现,也就是会泄漏一些不应该不使用的实现。举个例子,A 依赖 B,B 依赖 C,如果都是使用 api 配置的话,A 可以直接使用 C 中的类(编译时和运行时)。而如果是使用 implementation 配置的话,在编译时,A 无法访问 C 中的类。
  • compileOnly:与 provided 对应,Gradle 把依赖加到编译路径,编译时使用,不会打包到输出(aar 或 apk)。这可以减少输出的体积,在只在编译时需要,在运行时可选的情况,很有用。
  • runtimeOnly:与 apk 对应。Gradle添加依赖只打包到 apk,运行时使用,但不会添加到编译路径。这个没有使用过。
  • annotationProcessor:与 compile 对应,用于注解处理器的依赖配置,这个没用过。

查看依赖树

可以查看单个module或者这个project的依赖,通过运行依赖的 Gradle 任务,如下:

  1. View -> Tools Windows -> Gradle(或者点击右侧的 Gradle 栏);
  2. 展开 AppName -> Tasks -> Android,然后双击运行 AndroidDependencies。运行完,就会在 Run 窗口打出依赖树了。

依赖冲突解决

随着很多依赖加入到项目中,难免会出现依赖冲突,出现依赖冲突如何解决?

定位冲突

依赖冲突可能会报类似下面的错误:

Program type already present com.example.MyClass
通过查找类的方式(command + O)定位到冲突的依赖,进行排除。

如何排除依赖

dependencies 中排除(细粒度)
compile('com.taobao.android:accs-huawei:1.1.2@aar') {
        transitive = true
        exclude group: 'com.taobao.android', module: 'accs_sdk_taobao'
}

全局配置排除

configurations {
    compile.exclude module: 'cglib'
    //全局排除原有的tnet jar包与so包分离的配置,统一使用aar包中的内容
    all*.exclude group: 'com.taobao.android', module: 'tnet-jni'
    all*.exclude group: 'com.taobao.android', module: 'tnet-so'
}

禁用依赖传递

compile('com.zhyea:ar4j:1.0') {
    transitive = false
}

configurations.all {
    transitive = false
}

还可以在单个依赖项中使用 @jar 标识符忽略传递依赖:

compile 'com.zhyea:ar4j:1.0@jar'
强制使用某个版本

如果某个依赖项是必需的,而又存在依赖冲突时,此时没必要逐个进行排除,可以使用force属性标识需要进行依赖统一。当然这也是可以全局配置的:

compile('com.zhyea:ar4j:1.0') {
    force = true
}

configurations.all {
    resolutionStrategy {
        force 'org.hamcrest:hamcrest-core:1.3'
    }
}

在打包时排除依赖

先看一个示例:

task zip(type: Zip) {
    into('lib') {
        from(configurations.runtime) {
            exclude '*unwanted*', '*log*'
        }
    }
    into('') {
        from jar
        from 'doc'
    }
}

代码表示在打 zip 包的时候会过滤掉名称中包含 “unwanted” 和 “log” 的 jar 包。这里调用的 exclude 方法的参数和前面的例子不太一样,前面的参数多是 map 结构,这里则是一个正则表达式字符串。

也可以使用在打包时调用 include 方法选择只打包某些需要的依赖项:

task zip(type: Zip) {
    into('lib') {
        from(configurations.runtime) {
            include '*ar4j*', '*spring*'
        }
    }
    into('') {
        from jar
        from 'doc'
    }
}

主要是使用 dependencies 中排除和全局配置排除。

相关文章

]]>
//www.klh31.com/31297.html/feed 0
HashMap?面试?我是谁?我在哪 - ★广西快3龙虎★ //www.klh31.com/31278.html //www.klh31.com/31278.html#comments Wed, 09 Jan 2019 15:23:11 +0000 唐尤华 //www.klh31.com/?p=31278 现在是晚上11点了,学校屠猪馆的自习室因为太晚要关闭了。勤奋且疲惫的小鲁班也从屠猪馆出来了,正准备回宿舍洗洗睡,由于自习室位置比较偏僻所以是接收不到手机网络信号的,因此小鲁班从兜里掏出手机的时候,信息可真是炸了呀。小鲁班心想,微信群平时都没什么人聊天,今晚肯定是发生了什么大事。仔细一看,才发现原来是小鲁班的室友达摩(光头)拿到了阿里巴巴 Java 开发实习生的 Offer,此时小鲁班真替他室友感到高兴的同时,心里也难免会产生一丝丝的失落感,那是因为自己投了很多份简历,别说拿不拿得到 Offer,就连给面试邀的公司也都寥寥无几。小鲁班这会可真是受到了一万点真实暴击。不过小鲁班还是很乐观的,很快调整了心态,带上耳机,慢慢的走回了宿舍,正打算准备向他那神室友达摩取取经。

片刻后~

小鲁班:666,听说你拿到了阿里的 Offer,能透露一下面试内容和技巧吗?
达摩:嘿嘿嘿,没问题鸭,叫声爸爸我就告诉你。
小鲁班:耙耙(表面笑嘻嘻,心里MMP)
达摩:其实我也不是很记得了(请继续装),但我还是记得那么一些。如果你是面的 Java,首先当然是JAVA的基础知识:数据结构(Map / List / Set等)、设计模式、算法、线程相关、IO/NIO、序列化等等。其次是高级特征:反射机制,并发与锁,JVM(GC策略,类加载机制,内存模型)等等。
小鲁班:问这么多内容,那岂不是一个人都面试很久吗?
达摩:不是的,面试官一般都会用连环炮的方式提问的。
小鲁班:你说的连环炮是什么意思鸭?
达摩:那我举个例子:

  • 就比如问你?HashMap 是不是有序的?你回答不是有序的。
  • 那面试官就会可能继续问你,有没有有序的Map实现类呢?你如果这个时候说不知道的话,那这块问题就到此结束了。如果你说有 TreeMap 和 LinkedHashMap。
  • 那么面试官接下来就可能会问你,TreeMap 和 LinkedHashMap 是如何保证它的顺序的?如果你回答不上来,那么到此为止。如果你说 TreeMap 是通过实现 SortMap 接口,能够把它保存的键值对根据 key 排序,基于红黑树,从而保证 TreeMap 中所有键值对处于有序状态。LinkedHashMap 则是通过插入排序(就是你 put 的时候的顺序是什么,取出来的时候就是什么样子)和访问排序(改变排序把访问过的放到底部)让键值有序。
  • 那么面试官还会继续问你,你觉得它们两个哪个的有序实现比较好?如果你依然可以回答的话,那么面试官会继续问你,你觉得还有没有比它更好或者更高效的实现方式?

无穷无尽深入,直到你回答不出来或者面试官认为问题到底了。

小鲁班捏了一把汗,我去……这是魔鬼吧,那我们来试试呗(因为小鲁班刚刚在自习室才看了这章的知识,想趁机装一波逼,毕竟刚刚叫了声爸爸~~)

于是达摩 and 小鲁班就开始了对决:

1、为什么用HashMap?

  • HashMap 是一个散列桶(数组和链表),它存储的内容是键值对 key-value 映射
  • HashMap 采用了数组和链表的数据结构,能在查询和修改方便继承了数组的线性查找和链表的寻址修改
  • HashMap 是非 synchronized,所以 HashMap 很快
  • HashMap 可以接受 null 键和值,而 Hashtable 则不能(原因就是 equlas() 方法需要对象,因为 HashMap 是后出的 API 经过处理才可以)

2、HashMap 的工作原理是什么?

HashMap 是基于 hashing 的原理

我们使用 put(key, value) 存储对象到 HashMap 中,使用 get(key) 从 HashMap 中获取对象。当我们给 put() 方法传递键和值时,我们先对键调用 hashCode() 方法,计算并返回的 hashCode 是用于找到 Map 数组的 bucket 位置来储存 Node 对象。

这里关键点在于指出,HashMap 是在 bucket 中储存键对象和值对象,作为Map.Node 。

以下是 HashMap 初始化

简化的模拟数据结构:

Node[] table = new Node[16]; // 散列桶初始化,table
class Node {
    hash; //hash值
    key; //键
    value; //值
    node next; //用于指向链表的下一层(产生冲突,用拉链法)
}

以下是具体的 put 过程(JDK1.8)

  1. 对 Key 求 Hash 值,然后再计算下标
  2. 如果没有碰撞,直接放入桶中(碰撞的意思是计算得到的 Hash 值相同,需要放到同一个 bucket 中)
  3. 如果碰撞了,以链表的方式链接到后面
  4. 如果链表长度超过阀值(TREEIFY THRESHOLD==8),就把链表转成红黑树,链表长度低于6,就把红黑树转回链表
  5. 如果节点已经存在就替换旧值
  6. 如果桶满了(容量16*加载因子0.75),就需要 resize(扩容2倍后重排)

以下是具体 get 过程

考虑特殊情况:如果两个键的 hashcode 相同,你如何获取值对象?

当我们调用 get() 方法,HashMap 会使用键对象的 hashcode 找到 bucket 位置,找到 bucket 位置之后,会调用 keys.equals() 方法去找到链表中正确的节点,最终找到要找的值对象。

3、有什么方法可以减少碰撞?

扰动函数可以减少碰撞

原理是如果两个不相等的对象返回不同的 hashcode 的话,那么碰撞的几率就会小些。这就意味着存链表结构减小,这样取值的话就不会频繁调用 equal 方法,从而提高 HashMap 的性能(扰动即 Hash 方法内部的算法实现,目的是让不同对象返回不同hashcode)。

使用不可变的、声明作 final 对象,并且采用合适的 equals() 和 hashCode() 方法,将会减少碰撞的发生

不可变性使得能够缓存不同键的 hashcode,这将提高整个获取对象的速度,使用 String、Integer 这样的 wrapper 类作为键是非常好的选择。

为什么 String、Integer 这样的 wrapper 类适合作为键?

因为 String 是 final,而且已经重写了 equals() 和 hashCode() 方法了。不可变性是必要的,因为为了要计算 hashCode(),就要防止键值改变,如果键值在放入时和获取时返回不同的 hashcode 的话,那么就不能从 HashMap 中找到你想要的对象。

4、HashMap 中 hash 函数怎么是实现的?

我们可以看到,在 hashmap 中要找到某个元素,需要根据 key 的 hash 值来求得对应数组中的位置。如何计算这个位置就是 hash 算法。

前面说过,hashmap 的数据结构是数组和链表的结合,所以我们当然希望这个 hashmap 里面的元素位置尽量的分布均匀些,尽量使得每个位置上的元素数量只有一个。那么当我们用 hash 算法求得这个位置的时候,马上就可以知道对应位置的元素就是我们要的,而不用再去遍历链表。 所以,我们首先想到的就是把 hashcode 对数组长度取模运算。这样一来,元素的分布相对来说是比较均匀的。

但是“?!痹怂愕南幕故潜冉洗蟮?,能不能找一种更快速、消耗更小的方式?我们来看看 JDK1.8 源码是怎么做的(被楼主修饰了一下)

static final int hash(Object key) {
    if (key == null){
        return 0;
    }
    int h;
    h = key.hashCode();返回散列值也就是hashcode
    // ^ :按位异或
    // >>>:无符号右移,忽略符号位,空位都以0补齐
    //其中n是数组的长度,即Map的数组部分初始化长度
    return (n-1)&(h ^ (h >>> 16));
}

简单来说就是:

  • 高16 bit 不变,低16 bit 和高16 bit 做了一个异或(得到的 hashcode 转化为32位二进制,前16位和后16位低16 bit和高16 bit做了一个异或)
  • (n·1) & hash = -> 得到下标

5、拉链法导致的链表过深,为什么不用二叉查找树代替而选择红黑树?为什么不一直使用红黑树?

之所以选择红黑树是为了解决二叉查找树的缺陷:二叉查找树在特殊情况下会变成一条线性结构(这就跟原来使用链表结构一样了,造成层次很深的问题),遍历查找会非常慢。而红黑树在插入新数据后可能需要通过左旋、右旋、变色这些操作来保持平衡。引入红黑树就是为了查找数据快,解决链表查询深度的问题。我们知道红黑树属于平衡二叉树,为了保持“平衡”是需要付出代价的,但是该代价所损耗的资源要比遍历线性链表要少。所以当长度大于8的时候,会使用红黑树;如果链表长度很短的话,根本不需要引入红黑树,引入反而会慢。

6、说说你对红黑树的见解?

  1. 每个节点非红即黑
  2. 根节点总是黑色的
  3. 如果节点是红色的,则它的子节点必须是黑色的(反之不一定)
  4. 每个叶子节点都是黑色的空节点(NIL节点)
  5. 从根节点到叶节点或空子节点的每条路径,必须包含相同数目的黑色节点(即相同的黑色高度)

7、解决 hash 碰撞还有那些办法?

开放定址法

当冲突发生时,使用某种探查技术在散列表中形成一个探查(测)序列。沿此序列逐个单元地查找,直到找到给定的地址。按照形成探查序列的方法不同,可将开放定址法区分为线性探查法、二次探查法、双重散列法等。

下面给一个线性探查法的例子:

问题:已知一组关键字为 (26,36,41,38,44,15,68,12,06,51),用除余法构造散列函数,用线性探查法解决冲突构造这组关键字的散列表。
解答:为了减少冲突,通常令装填因子 α 由除余法因子是13的散列函数计算出的上述关键字序列的散列地址为 (0,10,2,12,5,2,3,12,6,12)。
前5个关键字插入时,其相应的地址均为开放地址,故将它们直接插入 T[0]、T[10)、T[2]、T[12] 和 T[5] 中。
当插入第6个关键字15时,其散列地址2(即 h(15)=15%13=2)已被关键字 41(15和41互为同义词)占用。故探查 h1=(2+1)%13=3,此地址开放,所以将 15 放入 T[3] 中。
当插入第7个关键字68时,其散列地址3已被非同义词15先占用,故将其插入到T[4]中。
当插入第8个关键字12时,散列地址12已被同义词38占用,故探查 hl=(12+1)%13=0,而 T[0] 亦被26占用,再探查 h2=(12+2)%13=1,此地址开放,可将12插入其中。
类似地,第9个关键字06直接插入 T[6] 中;而最后一个关键字51插人时,因探查的地址 12,0,1,…,6 均非空,故51插入 T[7] 中。

8、如果 HashMap 的大小超过了负载因子(load factor)定义的容量怎么办?

HashMap 默认的负载因子大小为0.75。也就是说,当一个 Map 填满了75%的 bucket 时候,和其它集合类一样(如 ArrayList 等),将会创建原来 HashMap 大小的两倍的 bucket 数组来重新调整 Map 大小,并将原来的对象放入新的 bucket 数组中。这个过程叫作 rehashing。

因为它调用 hash 方法找到新的 bucket 位置。这个值只可能在两个地方,一个是原下标的位置,另一种是在下标为 <原下标+原容量> 的位置。

9、重新调整 HashMap 大小存在什么问题吗?

重新调整 HashMap 大小的时候,确实存在条件竞争。

因为如果两个线程都发现 HashMap 需要重新调整大小了,它们会同时试着调整大小。在调整大小的过程中,存储在链表中的元素的次序会反过来。因为移动到新的 bucket 位置的时候,HashMap 并不会将元素放在链表的尾部,而是放在头部。这是为了避免尾部遍历(tail traversing)。如果条件竞争发生了,那么就死循环了。多线程的环境下不使用 HashMap。

为什么多线程会导致死循环,它是怎么发生的?

HashMap 的容量是有限的。当经过多次元素插入,使得 HashMap 达到一定饱和度时,Key 映射位置发生冲突的几率会逐渐提高。这时候, HashMap 需要扩展它的长度,也就是进行Resize。

  1. 扩容:创建一个新的 Entry 空数组,长度是原数组的2倍
  2. rehash:遍历原 Entry 数组,把所有的 Entry 重新 Hash 到新数组

(这个过程比较烧脑,暂不作流程图演示,有兴趣去看看我的另一篇博文“HashMap扩容全过程”)

达摩:哎呦,小老弟不错嘛~~意料之外呀
小鲁班:嘿嘿,优秀吧,中场休息一波,我先喝口水
达摩:不仅仅是这些哦,面试官还会问你相关的集合类对比,比如:

10、HashTable

  • 数组 + 链表方式存储
  • 默认容量:11(质数为宜)
  • put操作:首先进行索引计算 (key.hashCode() & 0x7FFFFFFF)% table.length;若在链表中找到了,则替换旧值,若未找到则继续;当总元素个数超过 容量 * 加载因子 时,扩容为原来 2 倍并重新散列;将新元素加到链表头部
  • 对修改 Hashtable 内部共享数据的方法添加了 synchronized,保证线程安全

11、HashMap 与 HashTable 区别

  • 默认容量不同,扩容不同
  • 线程安全性:HashTable 安全
  • 效率不同:HashTable 要慢,因为加锁

12、可以使用 CocurrentHashMap 来代替 Hashtable 吗?

  • 我们知道 Hashtable 是 synchronized 的,但是 ConcurrentHashMap 同步性能更好,因为它仅仅根据同步级别对 map 的一部分进行上锁
  • ConcurrentHashMap 当然可以代替 HashTable,但是 HashTable 提供更强的线程安全性
  • 它们都可以用于多线程的环境,但是当 Hashtable 的大小增加到一定的时候,性能会急剧下降,因为迭代时需要被锁定很长的时间。由于 ConcurrentHashMap 引入了分割(segmentation),不论它变得多么大,仅仅需要锁定 Map 的某个部分,其它的线程不需要等到迭代完成才能访问 Map。简而言之,在迭代的过程中,ConcurrentHashMap 仅仅锁定 Map 的某个部分,而 Hashtable 则会锁定整个 Map

13、CocurrentHashMap(JDK 1.7)

  • CocurrentHashMap 是由 Segment 数组和 HashEntry 数组和链表组成
  • Segment 是基于重入锁(ReentrantLock):一个数据段竞争锁。每个 HashEntry 一个链表结构的元素,利用 Hash 算法得到索引确定归属的数据段,也就是对应到在修改时需要竞争获取的锁。ConcurrentHashMap 支持 CurrencyLevel(Segment 数组数量)的线程并发。每当一个线程占用锁访问一个 Segment 时,不会影响到其他的 Segment
  • 核心数据如 value,以及链表都是 volatile 修饰的,保证了获取时的可见性
  • 首先是通过 key 定位到 Segment,之后在对应的 Segment 中进行具体的 put 操作如下:
    • 将当前 Segment 中的 table 通过 key 的 hashcode 定位到 HashEntry。
    • 遍历该 HashEntry,如果不为空则判断传入的? key 和当前遍历的 key 是否相等,相等则覆盖旧的 value
    • 不为空则需要新建一个 HashEntry 并加入到 Segment 中,同时会先判断是否需要扩容
    • 最后会解除在 1 中所获取当前 Segment 的锁。
  • 虽然 HashEntry 中的 value 是用 volatile 关键词修饰的,但是并不能保证并发的原子性,所以 put 操作时仍然需要加锁处理

首先第一步的时候会尝试获取锁,如果获取失败肯定就有其他线程存在竞争,则利用 scanAndLockForPut() 自旋获取锁。

  • 尝试自旋获取锁
  • 如果重试的次数达到了 MAX_SCAN_RETRIES 则改为阻塞锁获取,保证能获取成功。最后解除当前 Segment 的锁

14、CocurrentHashMap(JDK 1.8)

CocurrentHashMap?抛弃了原有的 Segment 分段锁,采用了?CAS + synchronized?来保证并发安全性。其中的?val next?都用了 volatile 修饰,保证了可见性。

最大特点是引入了 CAS

借助 Unsafe 来实现 native code。CAS有3个操作数,内存值 V、旧的预期值 A、要修改的新值 B。当且仅当预期值 A 和内存值 V 相同时,将内存值V修改为 B,否则什么都不做。Unsafe 借助 CPU 指令 cmpxchg 来实现。

CAS 使用实例

对 sizeCtl 的控制都是用 CAS 来实现的:

  • -1 代表 table 正在初始化
  • N 表示有 -N-1 个线程正在进行扩容操作
  • 如果 table 未初始化,表示table需要初始化的大小
  • 如果 table 初始化完成,表示table的容量,默认是table大小的0.75倍,用这个公式算 0.75(n – (n >>> 2))

CAS 会出现的问题:ABA

解决:对变量增加一个版本号,每次修改,版本号加 1,比较的时候比较版本号。

put 过程

  • 根据 key 计算出 hashcode
  • 判断是否需要进行初始化
  • 通过 key 定位出的 Node,如果为空表示当前位置可以写入数据,利用 CAS 尝试写入,失败则自旋保证成功
  • 如果当前位置的 hashcode == MOVED == -1,则需要进行扩容
  • 如果都不满足,则利用 synchronized 锁写入数据
  • 如果数量大于 TREEIFY_THRESHOLD 则要转换为红黑树

get 过程

  • 根据计算出来的 hashcode 寻址,如果就在桶上那么直接返回值
  • 如果是红黑树那就按照树的方式获取值
  • 就不满足那就按照链表的方式遍历获取值

此时躺着床上的张飞哄了一声:睡觉了睡觉了~

见此不太妙:小鲁班立马回到床上把被子盖过头,心里有一丝丝愉悦感。不对,好像还没洗澡……

by the way

ConcurrentHashMap 在 Java 8 中存在一个 bug 会进入死循环,原因是递归创建 ConcurrentHashMap 对象,但是在 JDK 1.9 已经修复了。场景重现如下:

public class ConcurrentHashMapDemo{
    private Map<Integer,Integer> cache =new ConcurrentHashMap<>(15);

    public static void main(String[]args){
        ConcurrentHashMapDemo ch =    new ConcurrentHashMapDemo();
        System.out.println(ch.fibonaacci(80));        
    }

    public int fibonaacci(Integer i){        
        if(i==0||i ==1) {                
            return i;        
        }

        return cache.computeIfAbsent(i,(key) -> {
            System.out.println("fibonaacci : "+key);
            return fibonaacci(key -1)+fibonaacci(key - 2);        
        });       
    }
}

相关文章

]]>
//www.klh31.com/31278.html/feed 4
用信鸽来解释 HTTPS - ★广西快3龙虎★ //www.klh31.com/31253.html //www.klh31.com/31253.html#comments Wed, 09 Jan 2019 00:00:53 +0000 唐尤华 //www.klh31.com/?p=31253 密码学是一门难以理解的学科,因为它充满了数学定理。但是除非你要实际开发出一套加密算法系统,否则你是没必要强制理解那些深奥的数学定理的。

如果你阅读本文的目的是想设计下一套 HTTPS 协议,那我只能抱歉的说本文的知识还远远不够;如果不是的话,那么就煮杯咖啡,轻松愉悦的阅读本文吧。

爱丽丝、鲍伯和 … 信鸽?

你在互联网上从事的任何活动(阅读这篇文章、在亚马逊上购物、上传图片等)归结到底都是从某台服务器上发送和接收信息。

这个说起来可能有点抽象,不如让我们假设这些消息都是由信鸽来传递的。我知道这个假设有些太过随意,但相信我 HTTPS 就是这样工作的,尽管它的速度快的多。

我们先不谈服务器、客户端或者黑客攻击,先来聊一下爱丽丝、鲍伯和马洛里。如果这已不是你第一次接触密码学理论,你应该会认识这些名字,因为他们经常在各种密码学文献中被提及。

一个简单的通信方式

如果爱丽丝想给鲍伯发个消息,她会把消息绑在信鸽的腿上寄给鲍伯。然后鲍伯收到了消息,并阅读了它。这一切都是美好的。

但如果马洛里拦截了爱丽丝飞翔中的信鸽并且修改消息内容呢?鲍伯将无法知道爱丽丝发来的消息已经在传输过程中被修改了。

这就是 HTTP 的工作方式,很可怕吧?我绝不会通过 HTTP 发送我的银行凭证,希望你也不会。

隐蔽的密码

那么如果爱丽丝和鲍勃都非常的机智。他们一致认同使用一种隐蔽的密码来书写他们的信息。他们会将信息中的每个字母按照字母表中的顺序前移三位。比如,D→A,E→B,F→C。如此一来,原文为 “secret message” 的信息就变成了 “pbzobq jbppxdb” 。

那现在如果马洛里再截获了信鸽,她既不能做出有意义的修改同时也不会知道信息的内容,因为她不知道隐蔽的密码到底是什么。然而鲍勃却可以很容易反转密码,依靠 A → D, B → E, C → F 之类的规则破译信息的内容。加密后的信息 “pbzobq jbppxdb” 会被破解还原为 “secret message” 。

搞定!

这就是对称密匙加密,因为如果你知道如何加密一段信息那么你同样可以解密这段信息。

上述的密码通常被称为凯撒码。在现实生活中,我们会使用更为奇特和复杂的密码,但原理相同。

我们如何决定密匙?

如果除了发信者和收信者之外没有人知道使用的是什么密匙,对称密匙加密是非常安全的。在凯撒加密中,密匙就是每个字母变到加密字母需要移动多少位的偏移量。我之前的距离中,使用的偏移量是 3 ,但是也可以用 4 或者 12 。

问题是如果爱丽丝和鲍勃在开始用信鸽传信之前没有碰过头,他们没有一个安全的方式来确立密匙。如果他们自己来在信中传递密匙,马洛里就会截获信息并发现密匙。这就使得马洛里可以在爱丽丝和鲍勃开始加密他们的信息之前或之后,阅读到他们信息的内容并按照她的意愿来篡改信息。

这是一个中间人攻击的典型例子,避免这个问题的唯一方法就是收发信的两方一起修改他们的编码系统。

通过信鸽传递盒子

所以爱丽丝和鲍勃就想出了一个更好的系统。当鲍勃想要给爱丽丝发送信息时,他会按照如下的步骤来进行:

  • 鲍勃向爱丽丝送一只没有携带任何信息的鸽子。
  • 爱丽丝给鲍勃送回鸽子,并且这只鸽子带有一个有开着的锁的盒子,爱丽丝保管着锁的钥匙。
  • 鲍勃把信放进盒子中,把锁锁上然后把盒子送给爱丽丝。
  • 爱丽丝收到盒子,用钥匙打开然后阅读信息。

这样马洛里就不能通过截获鸽子来篡改信息了,因为她没有打开盒子的钥匙。当爱丽丝要给鲍勃发送消息的时候同样按照上述的流程。

爱丽丝和鲍勃所使用的流程通常被称为非对称密钥加密。之所以称之为非对称,是因为即使是你把信息编码(锁上盒子)也不能破译信息(打开锁住的盒子)。

在术语中,盒子被称为公匙而用来打开盒子的钥匙被称为私匙。

如何信任盒子

如果你稍加注意你就会发现还是存在问题。当鲍勃收到盒子时他如何能确定这个盒子来自爱丽丝而不是马洛里截获了鸽子然后换了一个她有钥匙能打开的盒子呢?

爱丽丝决定签名标记一下盒子,这样鲍勃收到盒子的时候就可以检查签名来确定是爱丽丝送出的盒子了。

那么你们之中的一些人可能就会想了,鲍勃如何打一开始就能识别出爱丽丝的签名呢?这是个好问题。爱丽丝和鲍勃也确实有这个问题,所以他们决定让泰德代替爱丽丝来标记这个盒子。

那么谁是泰德呢?泰德很有名的,是一个值得信任的家伙。他会给任何人签名并且所有人都信任他只会给合法的人签名标记盒子。

如果泰德可以确认索要签名的人是爱丽丝,他就会在爱丽丝的盒子上签名。因此马洛里就不可能搞到一个有着泰德代表爱丽丝签了名的盒子,因为鲍勃知道泰德只会给他确认过的人签名,从而识破马洛里的诡计。

泰德的角色在术语中被称为认证机构。而你阅读此文时所用的浏览器打包存有许多认证机构的签名。

所以当你首次接入一个网站的时候你可以信任来自这个站点的盒子因为你信任泰德而泰德会告诉你盒子是合法的。

沉重的盒子

现在爱丽丝和鲍勃有了一个可靠的系统来进行交流,然他们也意识到让鸽子携带盒子比原本只携带信件要慢一些。

因此他们决定只有在选择用对称加密来给信息编码(还记得凯撒加密法吧?)的密匙时,使用传递盒子的方法(非对称加密)。

这样就可以二者的优点兼具了,非对称加密的可靠性和对称加密的高效性。

现实世界中我们不会用信鸽这样慢的送信手段,但用非对称加密来编码信息仍要慢于使用对称加密技术,所以我们只有在交换编码密匙的时候会使用非对称加密技术。

现在你已经了解了HTTPS是如何工作的了,你的咖啡也应该准备好了。好好享用吧你受之无愧。

相关文章

]]>
//www.klh31.com/31253.html/feed 3
一文快速了解Java集合框架 - ★广西快3龙虎★ //www.klh31.com/31223.html //www.klh31.com/31223.html#comments Sat, 05 Jan 2019 14:34:05 +0000 唐尤华 //www.klh31.com/?p=31223 1. 简介

JDK1.2 引入了 Java 集合框架,包含一组数据结构。与数组不同,这些数据结构的存储空间会随着元素添加动态增加。其中,一些支持添加重复元素另一些不支持,一些支持 null,一些能自动升序打印元素。

所有这些数据结构在 java.util 包里,包含了 Collection、List、Set、Map、SortedMap 接口。这些接口的实现类有 LinkedList、TreeSet、ArrayList、HashMap 等。除了这些数据结构,java.util 包还提供了?Date、GregorianCalender、StringTokenizer、Random 这样的工具类。

2. 分类

可以按照接口、实现、算法三个方面对集合框架中的数据结构进行分类:

  • 接口:Collection、List、Map 组成了集合框架中所有具体实现类的接口,它们定义了子类必须实现的方法,非常好记。比如向集合添加元素,会用到 Collection 中定义的 add() 方法
  • 实现:所有实现了上述3个接口的类,都被称作集合框架,实际上就是数据结构。比如 LinkedList、TreeSet 等
  • 算法:集合框架提供了很多可以直接调用的算法,比如求最大最小值、排序、填充等

3. 优缺点

有以下4个优点

  • 减少工作量的同时增加了软件的可用性:不需要每个程序员动手实现排序、查找、找出元素在数据结构中出现的次数
  • 执行速度更快更持久:集合框架的底层数据结构分为两类,基于节点的和基于数组的,前者在频繁添加时效率更高,后者在频繁读取时速度更快。一些数据结构是?synchronized 线程安全的,但会影响速度有,另一些则不是线程安全的。程序员在选用数据结构前要清楚地了解这些因素
  • 互操作与转换:由于实现了 Collection 接口,数据结构之间是可以相互转换的??梢?clone,可以把现有的结构转成?synchronized 版本,还可以在把基于链表的数据结构转为基于数组的结构

有以下2个缺点

  • 当心类型转换:在集合框架类之间进行转换时要大大地小心,尤其要考虑泛型类型的兼容性
  • 运行时类型检查:集合框架在运行时会抛出异常,需要编程时多加注意

4. 继承体系

java.util 中的数据结构继承体系分为两大类,一类实现了 Collection 接口,一类实现了 Map 接口。

Collection 继承体系Collection 继承体系(图片来自Wikipedia)

Map 继承体系

Map 继承体系(图片来自Wikipedia)

集合框架核心接口及实现类:

  • Collection:根接口,大部分数据结构都实现了 Collection 接口中的方法
  • Set:实现 Set 接口的数据结构不允许重复的元素,例如 HashSet、LinkedHashSet
  • SortedSet:实现 SortedSet 接口的数据结构默认可按升序打印元素,例如?TreeSet
  • List:实现 List 接口的数据结构允许重复元素,可通过 index 访问元素,例如 LinkedList、ArrayList、Vector
  • Map:实现 Map 接口的数据结构存储键值对,不允许重复的 key,例如 HashMap、LinkedHashMap、Hashtable
  • SortedMap:继承了 Map 接口,存储键值对,不允许重复的 key,默认可按 key 升序打印元素,例如 TreeMap

SortedSet 与 SortedMap 默认的排序是自然序,可通过 Comparator 或 Comparable 接口实现自定义排序。

在接口与具体的实现类之间还有一些抽象类,如下图:

这些抽象类为集合增加了很多功能:

  • HashSet:实现 Set 接口,不允许重复的元素,底层数据结构 hash table
  • LinkedHashSet:实现 Set 接口,不允许重复的元素,底层数据结构 hash table 与双链表
  • TreeSet:实现 NavigableSet 接口,不允许重复的元素,底层数据结构红黑树
  • ArrayList:实现 List 接口,允许重复元素,底层数据结构可变数组
  • LinkedList:实现?List?接口,允许重复元素,底层数据结构双链表
  • Vector:实现?List?接口,允许重复元素,底层数据结构可变数组
  • HashMap:实现 Map 接口,不允许重复的 key,底层数据结构 hash table
  • LinkedHashMap:实现 Map 接口,不允许重复的 key,底层数据结构?hash table 与双链表
  • HashTable:实现 Map 接口,不允许重复的 key,底层数据结构?hash table
  • TreeMap:实现 SortedMap 接口,不允许重复的 key,底层数据结构红黑树

可能感兴趣的文章

]]>
//www.klh31.com/31223.html/feed 0
JVM日历:Java 2018大事回顾 - ★广西快3龙虎★ //www.klh31.com/31161.html //www.klh31.com/31161.html#comments Fri, 04 Jan 2019 06:56:39 +0000 唐尤华 //www.klh31.com/?p=31161 一年过去了,是时候发布新一版 Java Advent 日历。这篇是发布的第六个日历,能够参与这一季的日历让我感到非常荣幸。比起专门讨论某个主题,我觉得更值得坐下来看看这一年发生的重大事件。这篇回顾专注于 Java 生态,内容应该不会让你感到陌生。

一月

  • 在2017年决定开源 Java EE 后,Oracle 在1月阐明了自己的命名规范与包命名。Java EE 守护者公布了他们的立场,关于Java EE 命名和打包的联合社区公开信,文中提出了可能的解决方案。两周内公布了官方回复。Red Hat 的 Mark Little 在他的博客中进行了总结。1月份,围绕新标准化过程的相关问题还在进行深入讨论没有答案
  • 其他重大新闻,JDK 有了一个孵化器项目。JEP12?提出了一个新的预览语言或者叫做 VM 特性,已经确认、实现但不是长期功能??梢酝ü?–incubating <version> 标签启用
  • Oracle 还宣布 Java 8 更新支持从2018年9月延长到2019年1月
  • 有关?EE4J 第一个版本发布的信息开始披露

二月

  • Java EE 新名字决定了:社区对 Jakarta EE 还是 Enterprise Profile 进行了投票,最终?Jakarta EE 获胜。提交了?EE.next 工作组?草案
  • 原本计划2018年3月20日发布 GA 版本,Java 10 RC1 发布了,这是Oracle六个月发布周期之后的第一次升级
  • 同样在这个月,第一个 EE4J 项目创建了项目的 GitHub 账号。?第一批提交并没有让人印象深刻的内容,包含的 API 项目并没有提供实现,看起来有点混乱
  • Apache NetBeans 9.0 beta 发布,对?Java 9 ??橄低程峁┩暾С?/span>

三月

  • Spring Boot 2.0 发布,支持 Java 9
  • 这个月,Oracle 宣布从 OpenJDK 中移除 JavaFX。这项措施通过解耦推动并促进 JavaFX 成为一项独立的技术。在完整的客户端路线图文档中PDF)还透露了?Java WebStart 从 JDK 11版本开始不再作为 JDK 的一部分
  • 在公布三月份发布的计划后,MicroProfile 重要的 1.4 和 2.0 版本延期

四月

  • 在 NX 半导体离开 Java Community Process(JCP)后,举行了一轮特别选举,阿里巴巴当选最新的 JCP 成员。2010年起,中国电子商务巨头阿里巴巴开始在 OpenJDK 上进行开发。阿里巴巴平台上运行的大多数应用程序用 Java 编写,这意味着超过十亿行代码和超过1万名Java工程师
  • JavaOne 成为历史了。在这篇博客中,Stephen Chin说到:JavaOne 将被整合到 Oracle OpenWorld 中,后者不仅仅讨论有关 Java 技术
  • 在新的Jakarta EE 网站发布期间,Microsoft 和 Lightbend 宣布作为参与成员加入 Jakarta EE 工作组
  • Oracle 发布了 GraalVM?可以更快地运行程序
  • 在一次与各路 Java 专家的系列访谈中,Java 社区表达了对 JDK 新功能、重要功能以及发布频率非常重视。不久,Oracle 用一份单独的FAQ回应了其中最紧迫的问题

五月

六月

七月

八月

九月

十月

十一月

可能感兴趣的文章

]]>
//www.klh31.com/31161.html/feed 0
JVM基础面试题及原理讲解 - ★广西快3龙虎★ //www.klh31.com/31126.html //www.klh31.com/31126.html#comments Thu, 03 Jan 2019 11:15:37 +0000 唐尤华 //www.klh31.com/?p=31126 本文从 JVM 结构入手,介绍了 Java 内存管理、对象创建、常量池等基础知识,对面试中 JVM 相关的基础题目进行了讲解。

写在前面(常见面试题)

基本问题

  • 介绍下 Java 内存区域(运行时数据区)
  • Java 对象的创建过程(五步,建议能默写出来并且要知道每一步虚拟机做了什么)
  • 对象的访问定位的两种方式(句柄和直接指针两种方式)

拓展问题

  • String类和常量池
  • 8种基本类型的包装类和常量池

1 概述

对于 Java 程序员来说,在虚拟机自动内存管理机制下,不再需要像C/C++程序开发程序员这样为内一个 new 操作去写对应的 delete/free 操作,不容易出现内存泄漏和内存溢出问题。正是因为 Java 程序员把内存控制权利交给 Java 虚拟机,一旦出现内存泄漏和溢出方面的问题,如果不了解虚拟机是怎样使用内存的,那么排查错误将会是一个非常艰巨的任务。

2 运行时数据区域

Java 虚拟机在执行 Java 程序的过程中会把它管理的内存划分成若干个不同的数据区域。

这些组成部分一些是线程私有的,其他的则是线程共享的。

线程私有的:

  • 程序计数器
  • 虚拟机栈
  • 本地方法栈

线程共享的:

  • 方法区
  • 直接内存

2.1 程序计数器

程序计数器是一块较小的内存空间,可以看作是当前线程所执行的字节码的行号指示器。字节码解释器工作时通过改变这个计数器的值来选取下一条需要执行的字节码指令,分支、循环、跳转、异常处理、线程恢复等功能都需要依赖这个计数器来完。

另外,为了线程切换后能恢复到正确的执行位置,每条线程都需要有一个独立的程序计数器,各线程之间计数器互不影响,独立存储,我们称这类内存区域为“线程私有”的内存。

从上面的介绍中我们知道程序计数器主要有两个作用:

  1. 字节码解释器通过改变程序计数器来依次读取指令,从而实现代码的流程控制,如:顺序执行、选择、循环、异常处理。
  2. 在多线程的情况下,程序计数器用于记录当前线程执行的位置,从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。

注意:程序计数器是唯不会出现 OutOfMemoryError 的内存区域,它的生命周期随着线程的创建而创建,随着线程的结束而死亡。

2.2 Java 虚拟机栈

与程序计数器一样,Java虚拟机栈也是线程私有的,它的生命周期和线程相同,描述的是 Java 方法执行的内存模型。

Java 内存可以粗糙的区分为堆内存(Heap)和栈内存(Stack)其中栈就是现在说的虚拟机栈,或者说是虚拟机栈中局部变量表部分。?(实际上,Java虚拟机栈是由一个个栈帧组成,而每个栈帧中都拥有局部变量表、操作数栈、动态链接、方法出口信息)

局部变量表主要存放了编译器可知的各种数据类型(boolean、byte、char、short、int、float、long、double)、对象引用(reference类型,它不同于对象本身,可能是一个指向对象起始地址的引用指针,也可能是指向一个代表对象的句柄或其他与此对象相关的位置)。

Java 虚拟机栈会出现两种异常:StackOverFlowError 和 OutOfMemoryError。

  • StackOverFlowError:?若Java虚拟机栈的内存大小不允许动态扩展,那么当线程请求栈的深度超过当前Java虚拟机栈的最大深度的时候,就抛出StackOverFlowError异常。
  • OutOfMemoryError:?若 Java 虚拟机栈的内存大小允许动态扩展,且当线程请求栈时内存用完了,无法再动态扩展了,此时抛出OutOfMemoryError异常。

Java 虚拟机栈也是线程私有的,每个线程都有各自的Java虚拟机栈,而且随着线程的创建而创建,随着线程的死亡而死亡。

2.3 本地方法栈

和虚拟机栈所发挥的作用非常相似,区别是:?虚拟机栈为虚拟机执行 Java 方法 (也就是字节码)服务,而本地方法栈则为虚拟机使用到的 Native 方法服务。?在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。

本地方法被执行的时候,在本地方法栈也会创建一个栈帧,用于存放该本地方法的局部变量表、操作数栈、动态链接、出口信息。

方法执行完毕后相应的栈帧也会出栈并释放内存空间,也会出现 StackOverFlowError 和 OutOfMemoryError 两种异常。

2.4 堆

Java 虚拟机所管理的内存中最大的一块,Java 堆是所有线程共享的一块内存区域,在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例,几乎所有的对象实例以及数组都在这里分配内存。

Java 堆是垃圾收集器管理的主要区域,因此也被称作GC堆(Garbage Collected Heap).从垃圾回收的角度,由于现在收集器基本都采用分代垃圾收集算法,所以Java堆还可以细分为:新生代和老年代:再细致一点有:Eden空间、From Survivor、To Survivor空间等。进一步划分的目的是更好地回收内存,或者更快地分配内存。

在 JDK 1.8中移除整个永久代,取而代之的是一个叫元空间(Metaspace)的区域(永久代使用的是JVM的堆内存空间,而元空间使用的是物理内存,直接受到本机的物理内存限制)。

推荐阅读:Java8内存模型——永久代(PermGen)和元空间(Metaspace)

2.5 方法区

方法区与 Java 堆一样,是各个线程共享的内存区域,它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分,但是它却有一个别名叫做 Non-Heap(非堆),目的应该是与 Java 堆区分开来。

HotSpot 虚拟机中方法区也常被称为?“永久代”,本质上两者并不等价。仅仅是因为 HotSpot 虚拟机设计团队用永久代来实现方法区而已,这样 HotSpot 虚拟机的垃圾收集器就可以像管理 Java 堆一样管理这部分内存了。但是这并不是一个好主意,因为这样更容易遇到内存溢出问题。

相对而言,垃圾收集行为在这个区域是比较少出现的,但并非数据进入方法区后就“永久存在”了。

2.6 运行时常量池

运行时常量池是方法区的一部分。Class 文件中除了有类的版本、字段、方法、接口等描述信息外,还有常量池信息(用于存放编译期生成的各种字面量和符号引用)

既然运行时常量池时方法区的一部分,自然受到方法区内存的限制,当常量池无法再申请到内存时会抛出 OutOfMemoryError 异常。

JDK1.7及之后版本的 JVM 已经将运行时常量池从方法区中移了出来,在 Java 堆(Heap)中开辟了一块区域存放运行时常量池。

推荐阅读:Java 中几种常量池的区分

2.7 直接内存

直接内存并不是虚拟机运行时数据区的一部分,也不是虚拟机规范中定义的内存区域,但是这部分内存也被频繁地使用。而且也可能导致OutOfMemoryError异常出现。

JDK1.4中新加入的?NIO(New Input/Output) 类,引入了一种基于通道(Channel)?与缓存区(Buffer)?的 I/O 方式,它可以直接使用Native函数库直接分配堆外内存,然后通过一个存储在 Java 堆中的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样就能在一些场景中显著提高性能,因为避免了在 Java 堆和 Native 堆之间来回复制数据。

本机直接内存的分配不会收到 Java 堆的限制,但是,既然是内存就会受到本机总内存大小以及处理器寻址空间的限制。

3 HotSpot 虚拟机对象探秘

通过上面的介绍我们大概知道了虚拟机的内存情况,下面我们来详细的了解一下 HotSpot 虚拟机在 Java 堆中对象分配、布局和访问的全过程。

3.1 对象的创建

下图便是 Java 对象的创建过程,我建议最好是能默写出来,并且要掌握每一步在做什么。

Java创建对象过程

Java创建对象过程

1. 类加载检查:?虚拟机遇到一条 new 指令时,首先将去检查这个指令的参数是否能在常量池中定位到这个类的符号引用,并且检查这个符号引用代表的类是否已被加载过、解析和初始化过。如果没有,那必须先执行相应的类加载过程。

2. 分配内存:?在类加载检查通过后,接下来虚拟机将为新生对象分配内存。对象所需的内存大小在类加载完成后便可确定,为对象分配空间的任务等同于把一块确定大小的内存从 Java 堆中划分出来。分配方式有?“指针碰撞”?和?“空闲列表”?两种,选择那种分配方式由 Java 堆是否规整决定,而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。

内存分配的两种方式:(补充内容,需要掌握)

选择以上两种方式中的哪一种,取决于 Java 堆内存是否规整。而 Java 堆内存是否规整,取决于 GC 收集器的算法是”标记-清除”,还是”标记-整理”(也称作”标记-压缩”),值得注意的是,复制算法内存也是规整的。

内存分配并发问题(补充内容,需要掌握)

在创建对象的时候有一个很重要的问题,就是线程安全,因为在实际开发过程中,创建对象是很频繁的事情,作为虚拟机来说,必须要保证线程是安全的,通常来讲,虚拟机采用两种方式来保证线程安全:

  • CAS+失败重试:?CAS 是乐观锁的一种实现方式。所谓乐观锁就是,每次不加锁而是假设没有冲突而去完成某项操作,如果因为冲突失败就重试,直到成功为止。虚拟机采用 CAS 配上失败重试的方式保证更新操作的原子性。
  • TLAB:?为每一个线程预先在 Eden 区分配一块内存。JVM 在给线程中的对象分配内存时,首先在 TLAB 分配,当对象大于TLAB 中的剩余内存或 TLAB 的内存已用尽时,再采用上述的 CAS 进行内存分配。

3. 初始化零值:?内存分配完成后,虚拟机需要将分配到的内存空间都初始化为零值(不包括对象头),这一步操作保证了对象的实例字段在 Java 代码中可以不赋初始值就直接使用,程序能访问到这些字段的数据类型所对应的零值。

4. 设置对象头:?初始化零值完成之后,虚拟机要对对象进行必要的设置,例如这个对象是那个类的实例、如何才能找到类的元数据信息、对象的哈希吗、对象的 GC 分代年龄等信息。?这些信息存放在对象头中。?另外,根据虚拟机当前运行状态的不同,如是否启用偏向锁等,对象头会有不同的设置方式。

5. 执行 init 方法:?在上面工作都完成之后,从虚拟机的视角来看,一个新的对象已经产生了,但从 Java 程序的视角来看,对象创建才刚开始,<init>?方法还没有执行,所有的字段都还为零。所以一般来说,执行 new 指令之后会接着执行?<init>?方法,把对象按照程序员的意愿进行初始化,这样一个真正可用的对象才算完全产生出来。

3.2 对象的内存布局

在 Hotspot 虚拟机中,对象在内存中的布局可以分为3块区域:对象头、实例数据和对齐填充。

Hotspot虚拟机的对象头包括两部分信息,第一部分用于存储对象自身的自身运行时数据(哈希码、GC分代年龄、锁状态标志等等),另一部分是类型指针,即对象指向它的类元数据的指针,虚拟机通过这个指针来确定这个对象是那个类的实例。

实例数据部分是对象真正存储的有效信息,也是在程序中所定义的各种类型的字段内容。

对齐填充部分不是必然存在的,也没有什么特别的含义,仅仅起占位作用。?因为 Hotspot 虚拟机的自动内存管理系统要求对象起始地址必须是8字节的整数倍,换句话说就是对象的大小必须是8字节的整数倍。而对象头部分正好是8字节的倍数(1倍或2倍),因此,当对象实例数据部分没有对齐时,就需要通过对齐填充来补全。

3.3 对象的访问定位

建立对象就是为了使用对象,我们的Java程序通过栈上的 reference 数据来操作堆上的具体对象。对象的访问方式有虚拟机实现而定,目前主流的访问方式有使用句柄和直接指针两种:

1. 句柄:?如果使用句柄的话,那么 Java 堆中将会划分出一块内存来作为句柄池,reference 中存储的就是对象的句柄地址,而句柄中包含了对象实例数据与类型数据各自的具体地址信息。

通过句柄访问对象

2. 直接指针:?如果使用直接指针访问,那么 Java 堆对象的布局中就必须考虑如何放置访问类型数据的相关信息,而 reference 中存储的直接就是对象的地址。

通过直接指针访问对象

这两种对象访问方式各有优势。使用句柄来访问的最大好处是 reference 中存储的是稳定的句柄地址,在对象被移动时只会改变句柄中的实例数据指针,而 reference 本身不需要修改。使用直接指针访问方式最大的好处就是速度快,它节省了一次指针定位的时间开销。

4 重点补充内容

4.1 String 类和常量池

1 String 对象的两种创建方式

String str1 = "abcd";
String str2 = new String("abcd");
System.out.println(str1==str2);//false

这两种不同的创建方法是有差别的,第一种方式是在常量池中拿对象,第二种方式是直接在堆内存空间创建一个新的对象。

记?。?/strong>只要使用 new 方法,便需要创建新的对象。

2 String 类型的常量池比较特殊。它的主要使用方法有两种:

  • 直接使用双引号声明出来的 String 对象会直接存储在常量池中。
  • 如果不是用双引号声明的 String 对象,可以使用 String 提供的 intern 方法。String.intern() 是一个 Native 方法,它的作用是:如果运行时常量池中已经包含一个等于此 String 对象内容的字符串,则返回常量池中该字符串的引用;如果没有,则在常量池中创建与此 String 内容相同的字符串,并返回常量池中创建的字符串的引用。
String s1 = new String("计算机");
String s2 = s1.intern();
String s3 = "计算机";
System.out.println(s2);//计算机
System.out.println(s1 == s2);//false,因为一个是堆内存中的String对象一个是常量池中的String对象,
System.out.println(s3 == s2);//true,因为两个都是常量池中的String对象

3 String 字符串拼接

String str1 = "str";
String str2 = "ing";

String str3 = "str" + "ing";//常量池中的对象
String str4 = str1 + str2; //在堆上创建的新的对象     
String str5 = "string";//常量池中的对象
System.out.println(str3 == str4);//false
System.out.println(str3 == str5);//true
System.out.println(str4 == str5);//false

尽量避免多个字符串拼接,因为这样会重新创建对象。如果需要改变字符串的话,可以使用 StringBuilder 或者 StringBuffer。

String s1 = new String("abc"); // 这句话创建了几个对象?

创建了两个对象。

验证:

String s1 = new String("abc");// 堆内存的地值值
String s2 = "abc";
System.out.println(s1 == s2);// 输出false,因为一个是堆内存,一个是常量池的内存,故两者是不同的。
System.out.println(s1.equals(s2));// 输出true

结果:

false
true

解释:

先有字符串 “abc” 放入常量池,然后 new 了一份字符串 “abc” 放入 Java 堆(字符串常量 “abc” 在编译期就已经确定放入常量池,而 Java 堆上的 “abc” 是在运行期初始化阶段才确定),然后 Java 栈的 str1 指向 Java 堆上的 “abc”。

4.2 8种基本类型的包装类和常量池

  • Java 基本类型的包装类的大部分都实现了常量池技术,即 Byte、Short、Integer、Long、Character、Boolean;这5种包装类默认创建了数值 [-128,127] 的相应类型的缓存数据,但是超出此范围仍然会去创建新的对象。
  • 两种浮点数类型的包装类 Float、Double 并没有实现常量池技术。
Integer i1 = 33;
Integer i2 = 33;
System.out.println(i1 == i2);// 输出true
Integer i11 = 333;
Integer i22 = 333;
System.out.println(i11 == i22);// 输出false
Double i3 = 1.2;
Double i4 = 1.2;
System.out.println(i3 == i4);// 输出false

Integer 缓存源代码:

/**
 *此方法将始终缓存-128到127(包括端点)范围内的值,并可以缓存此范围之外的其他值。
 */
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

应用场景:

  1. Integer i1=40;Java 在编译的时候会直接将代码封装成 Integer i1=Integer.valueOf(40); 从而使用常量池中的对象。
  2. Integer i1 = new Integer(40) ;这种情况下会创建新的对象。
Integer i1 = 40;
Integer i2 = new Integer(40);
System.out.println(i1==i2); //输出false

Integer 比较(==)更丰富的一个例子:

Integer i1 = 40;
Integer i2 = 40;
Integer i3 = 0;
Integer i4 = new Integer(40);
Integer i5 = new Integer(40);
Integer i6 = new Integer(0);

System.out.println("i1=i2   " + (i1 == i2));
System.out.println("i1=i2+i3   " + (i1 == i2 + i3));
System.out.println("i1=i4   " + (i1 == i4));
System.out.println("i4=i5   " + (i4 == i5));
System.out.println("i4=i5+i6   " + (i4 == i5 + i6));   
System.out.println("40=i5+i6   " + (40 == i5 + i6));

结果:

i1=i2   true
i1=i2+i3   true
i1=i4   false
i4=i5   false
i4=i5+i6   true
40=i5+i6   true

解释:

语句 i4 == i5 + i6,因为 + 这个操作符不适用于 Integer 对象,首先 i5 和 i6 进行自动拆箱操作,进行数值相加,即 i4 == 40。然后Integer对象无法与数值进行直接比较,所以i4自动拆箱转为int值40,最终这条语句转为40 == 40进行数值比较。

参考文档

相关文章

]]>
//www.klh31.com/31126.html/feed 3
Docker使用 linuxserver/letsencrypt 生成SSL证书最全解析及实践 - ★广西快3龙虎★ //www.klh31.com/31072.html //www.klh31.com/31072.html#comments Thu, 03 Jan 2019 00:30:49 +0000 唐尤华 //www.klh31.com/?p=31072 本文使用 HTTP 和 DNS 两种校验方式对 Docker 下 linuxserver/letsencrypt 项目进行了实践。生成SpringBoot可用证书,使用 Nginx 的 htpasswd 来对网站进行密码?;?,并测试使用 fail2ban 防止 htpasswd 被暴力破解。全文基于 linuxserver/letsencrypt 文档及其他官方资料,根据作者实践进行详细解析和记录。

1. 介绍

1.0 linuxserver/letsencrypt

这个容器设置了一个 Nginx 服务器,支持 PHP 的反向代理和一个内置的 letsencrypt 客户端,可以自动化生成或更新 SSL 服务器证书。它还包含用于防御入侵的 fail2ban。

1.1 使用

docker create \
  --cap-add=NET_ADMIN \
  --name=letsencrypt \
  -v <path to data>:/config \
  -e PGID=<gid> -e PUID=<uid>  \
  -e EMAIL=<email> \
  -e URL=<url> \
  -e SUBDOMAINS=<subdomains> \
  -e VALIDATION=<method> \
  -p 80:80 -p 443:443 \
  -e TZ=<timezone> \
  linuxserver/letsencrypt

1.2 参数

  • –cap-add=NET_ADMIN cap-add:即 Add Linux capabilities 添加 Linux 内核能力。这里具体添加的能力是允许执行网络管理任务。这是因为 fail2ban 需要修改 iptables
  • -p 80 -p 443:端口
  • -v /config:包括 webroot 在内的所有配置文件都保存在此处
  • -e URL:顶级域名(完全拥有则如:“customdomain.com”,动态 DNS 则如 “customsubdomain.ddnsprovider.com” )
  • -e SUBDOMAINS:证书覆盖的子域名 (逗号分隔,无空格) .如 www,ftp,cloud.对于通配符证书, 请将此明确地设置为通配符 (通配符证书只允许通过dns方式验证)
  • -e VALIDATION:letsencrypt验证方法,选项是 http、tls-sni 或者 DNS
  • 不同校验方式的区别:
    • HTTP 校验:需要使用到80端口,故宿主机80端口应该转发到容器的80端口
    • tls-sni 校验:需要使用到443端口,故宿主机443端口应该转发到容器的443端口(注意:由于安全漏洞,letsencrypt 禁用了 tls-sni 验证,使用该方式会报错:Client with the currently selected authenticator does not support any combination of challenges that will satisfy the CA
    • DNS 验证:需要设置 DNSPLUGIN 变量(不是所有的DNS服务商都支持),并且需要在 /config/dns-conf 文件夹下输入凭据到相应的 ini 文件里,当无法通过端口验证时可使用这种方法验证
  • -e PGID 设置 GroupID
  • -e PUID 设置 UserID
  • -e TZ?- 时区 如?America/New_York:上海时区为Asia/Shanghai

通过指定用户ID和所属群的ID来避免数据卷挂载(-v)时容器和宿主机直接可能产生的权限问题。最好让挂载的数据卷目录的拥有者和指定的用户统一。

另外,需要注意:不能指定root用户(即PGID=0,PUID=0),否则会一直报错(但不影响使用)。

#宿主机root用户环境下使用例子(非官方,仅供参考)

#创建要挂载的目录,此时该目录属root用户和root组
mkdir /opt/letsencrypt
#创建docker用户(默认会顺带新建同名Group)
useradd dockeruser
#修改文件夹归属(R代表递归操作,文件夹下的也一并修改)
chown -R dockeruser:dockeruser /opt/letsencrypt
#查看dockeruser的用户id和群id
id dockeruser

可选设置:

  • -e DNSPLUGIN:如果 VALIDATION 设置为 DNS 则此项必选。选项有 cloudflare、cloudxns、digitalocean、dnsimple、dnsmadeeasy、google、luadns、nsone、rfc2136 和 route53?;剐枰?/config/dns-conf 文件夹下输入凭据到相应的 ini 文件里。这里推荐使用 cloudflare,免费而且好用.
  • 使用 Cloudflare 服务的话应确保设置为 dns only 而非 dns + proxy(事实上 Cloudflare 的 proxy 已经提供免费自动 SSL 服务了,也就没有本文的必要)
  • Google DNS 插件的使用对象是企业付费产品“Google Cloud DNS”而非“Google Domains DNS”
  • -e EMAIL:您的证书注册和通知的电子邮件地址
  • -e DHLEVEL:dhparams 位值(默认值= 2048,可设置为1024或4096)
  • -p 80:VALIDATION设置为 http 而不是 dns 或 tls-sni 时需要80端口进行转发
  • -e ONLY_SUBDOMAINS:仅为子域名获取证书(主域名可能托管在另外一台计算机且无法验证)时请将此项设置为 true
  • -e EXTRA_DOMAINS:额外的完全限定域名(逗号分隔,无空格)如 extradomain.com,subdomain.anotherdomain.org
  • -e STAGING:设置为 true 可以提高速率限制,但证书不会通过浏览器的安全测试,仅用于测试
  • -e HTTPVAL:已弃用, 请用VALIDATION 代替

2. 实践

2.1 使用 HTTP 方式验证

首先,你应该先保证要获取证书的域名(子域名)能正确地访问到主机。注意:域名需要备案。

这里我映射的宿主机目录为 /opt/letsencrypt1,PGID 和 PUID 由上文提到的方式获得。配置的域名为 my.com 和 www.my.com (实际上我配置的是另外一个我自己真正拥有的域名,这里不贴出来)

注意:使用 HTTP 方式验证的话开发80端口就可以了,这里443端口也进行映射。这是为了证书获取成功后可以通过使用 HTTPS 登录该容器提供的默认首页进行确认。

docker run -d \
--cap-add=NET_ADMIN \
--name=letsencrypt \
-v /opt/letsencrypt1:/config \
-e PGID=1002 -e PUID=1001  \
-e URL=my.com \
-e SUBDOMAINS=www \
-e VALIDATION=http \
-p 80:80 -p 443:443 \
-e TZ=Asia/Shanghai \
linuxserver/letsencrypt

容器会在后台运行,这个时候应该提供如下指令查看日志输出(CTRL + z退出)

docker logs -f letsencrypt

最后,我卡在 Cleaning up challenges 这一步。这是因为我域名没有备案,无法通过域名访问到我所在的主机。这个时候打开域名链接被重定向到云主机提供商的网页禁止访问,Let’s encrypt 没办法通过域名访问到本机,所以验证失败(事实上它也没有说失败,只是一直停在那里)。

毋庸置疑,我是因为这个原因被禁止访问的。

既然 HTTP(80端口)方式验证走不通,tls-sni本来就不行,那就只能用 dns 验证了。

2.2 使用dns方式验证

这里以CloudFlare为例

第一步 完成域名服务器配置

首先,要有一个 cloudflare 账号。然后,在域名提供商那里将域名的 DNS 服务器改成 cloudflare 提供的 DNS 服务器。然后,在cloudflare那里添加对应的解析记录。

注意:解析记录 Status 的图标应该是灰色的,表示 DNS only。如果图标亮了,表示 DNS and HTTP proay(CDN),要使用 let’s encrypt 的 DNS 校验的话就不要再开 HTTP 代理和 CDN 了??舜淼幕?cloudflare 会免费给你提供(及自动维护更新)SSL证书,就可以直接 HTTP 访问了。不需要本文再干嘛了,而且还有免费 CDN,可谓十分良心。

第二步 完成域名服务器 API-KEY 相关配置并启动

这一步先正常启动,会启动失败但会生成所有的配置文件。再根据相应的 ini 文件里的提示去域名服务器提供商那里找到相对应的凭证,修改 ini 文件,重新启动容器。

启动如下。这次我映射到宿主机目录 /opt/letsencrypt2 下,把 VALIDATION 改为 dns,增加 DNSPLUGIN 配置为 cloudflare。

docker run -d \
--cap-add=NET_ADMIN \
--name=letsencrypt \
-v /opt/letsencrypt2:/config \
-e PGID=1002 -e PUID=1001  \
-e URL=my.com \
-e SUBDOMAINS=www \
-e VALIDATION=dns \
-e DNSPLUGIN=cloudflare \
-p 80:80 -p 443:443 \
-e TZ=Asia/Shanghai \
linuxserver/letsencrypt

使用 docker logs -f letsencrypt 查看。
这次是在 Cleaning up challenges 之后报错… 错误提示也很明确,是 Unknown X-Auth-Key or X-Auth-Email 的问题,配置是在 /config/dns-conf/cloudflare.ini?这个文件里面。

Cleaning up challenges
Error determining zone_id: 9103 Unknown X-Auth-Key or X-Auth-Email. Please confirm that you have supplied valid Cloudflare API credentials. (Did you enter the correct email address?)
IMPORTANT NOTES:
 - Your account credentials have been saved in your Certbot
   configuration directory at /etc/letsencrypt. You should make a
   secure backup of this folder now. This configuration directory will
   also contain certificates and private keys obtained by Certbot so
   making regular backups of this folder is ideal.
ERROR: Cert does not exist! Please see the validation error above. Make sure you entered correct credentials into the /config/dns-conf/cloudflare.ini file.

打开??/config/dns-conf/cloudflare.ini 可以看到

# Instructions: https://github.com/certbot/certbot/blob/master/certbot-dns-cloudflare/certbot_dns_cloudflare/__init__.py#L20
# Replace with your values
dns_cloudflare_email = cloudflare@example.com
dns_cloudflare_api_key = 0123456789abcdef0123456789abcdef01234567

感兴趣的可以到介绍的页面去查看相关信息,也可以直接到对应域名解析服务提供商那里去看。cloudflare 查看的地址是 https://dash.cloudflare.com/profile,最上面是 Email,最下面是 API Keys。


将对应内容替换到?/config/dns-conf/cloudflare.ini 里面(即宿主机的 /opt/letsencrypt2/dns-conf/cloudflare.ini 里面)。然后,使用 docker rm -f letsencrypt 强制删掉原容器。再重新运行上面的 docker run 就可以成功启动了。

查看日志如下:


最终会停在 Server ready 这一行(如果用 root 用户的 uid 和 gid 的话,现在会一直报错,但仍可使用)。这个时候就可以用 HTTPS 打开了(内置的 Nginx 只监听443端口,所以不能用 HTTP 打开),显示如下界面即为正常。

 

3. 设置

3.1 安全和密码?;?/h4>

可以使用 Nginx 的 htpasswd 来对网站进行密码?;?。htpasswd 的相关用法可见?htpasswd命令。

  • 添加第一个密码访问用户(-c?参数表示创建一个加密文件,如果原来有的话则把原来的删掉)
docker exec -it letsencrypt htpasswd -c /config/nginx/.htpasswd <username>
  • 继续添加密码访问用户(把-c去掉即可)
docker exec -it letsencrypt htpasswd /config/nginx/.htpasswd <username>

如下为添加两个用户(lin 和 shen)

查看用户信息文件(/opt/letsencrypt2 是我映射到容器 /config 的目录)

然后,还需要在 Nginx 的配置文件(默认为 /config/nginx/site-confs/default)里面开启 auth_basic,如下:

location / {
    try_files $uri $uri/ /index.html /index.php?$args =404;
    # 将下列两行放到location{}里面,**Restricted**是网站要求输入账号密码时的提示语,后面是指定的用户密码文件路径
    auth_basic "Restricted";
    auth_basic_user_file /config/nginx/.htpasswd;
}

最后要使用 docker restart letsencrypt 重新启动容器使配置生效。登录网站,提示如下(我用的是firefox,不同浏览器可能显示不一样)

3.2 站点配置和反向代理

3.2.1 默认配置文件

默认的站点配置文件位于 /config/nginx/site-confs/default??芍苯有薷拇宋募瓿膳渲?,也可将其他的 conf 文件添加到此目录。如果将 default 文件删除的话,容器启动时对其重新创建。

3.2.2 拒绝搜索引擎抓取

如果不希望网站被搜索引擎抓取,可以将以下命令添加到 /config/nginx 文件夹下的 ssl.conf 文件中。

add_header X-Robots-Tag "noindex, nofollow, nosnippet, noarchive";

3.2.3 使用预设的配置文件

本容器已经为热门应用添加了预设的反向代理配置文件,具体可以查看 /config/nginx/proxy_confs 文件夹下的 _readme 文件
/config/nginx/proxy_confs 文件夹下的预设反向代理配置文件有两类:

  • .subfolder.conf : 这类型的配置文件将允许通过 https://yourdomain.com/servicename 的方式访问配置文件对应的服务
  • .subdomain.conf : 这类型的配置文件将允许通过 https://servicename.yourdomain.com 的方式访问配置文件对应的服务

启用预设的配置文件:

  • 第一步 确保在默认站点配置文件(default文件)的server项内包含以下命令:
include /config/nginx/proxy-confs/*.subfolder.conf;
include /config/nginx/proxy-confs/*.subdomain.conf;
  • 第二步 重命名 conf 文件并删除结尾的 .sample?
  • 第三步 重启 letsencrypt 容器

3.3 证书相关

3.3.1 证书种类
  • cert.pem、chain.pem、fullchain.pem 和 privkey.pem。通过 letsencrypt 生成并由 Nginx 和其它各种应用使用
  • privkey.pfx:Microsoft支持的格式,常用于 Embnet Server 等 dotnet 应用程序(无密码)
  • priv-fullchain-bundle.pem:一个捆绑私钥和全链的 pem 证书,由 ZNC 等应用程序使用
3.3.2 在其他容器中使用证书

证书在容器中的存放在 config/etc/letsencrypt 文件夹下,又因为 /config 文件夹被映射到宿主机,故如果需要在其他容器中使用,可以再把宿主机对应目录下的 etc/letsencrypt 文件夹映射到需要用到证书的容器。

3.3.3 在SpringBoot 下使用

1. 将 pem 证书转为 JKS 格式,在此过程需要输入密码。这里使用的是网上的 SSL证书格式转换工具(https://www.chinassl.net/ssltools/convert-ssl.html

2. 在SpringBoot 里面配置。有了JKS证书和密码后配置就很简单了,这里不贴出来。

3.3.4 fail2ban

fail2ban 是一款实用软件,可以监视你的系统日志,然后匹配日志的错误信息(正则式匹配)执行相应的屏蔽动作。多用于防止暴力破解和 CC 攻击。

1. 文件结构

/config/fail2ban 目录下主要有一个 jail.local 文件和 filter.d、action.d 两个文件夹。另外,还有一个 fail2ban.sqlite3 的数据库文件,这个不用管

  • jail.local 文件:负责 fail2ban 的主要配置,统管所有 jail 的启用和禁用和监控规、日志路径等
  • filter.d 文件夹:存放各个 jail 的过滤器配置文件,如 nginx-http-auth.conf 文件等
  • action.d 文件夹:存放各种功能对应的配置文件,如 sendmail.conf 文件等
2. 使用说明
  • 该容器内置的fail2ban默认包括(并开启)3个jail
  1. nginx-http-auth
  2. nginx-badbots
  3. nginx-botsearch
  • 可以通过修改文件 /config/fail2ban/jail.local 去启用或禁用其他 jail
  • 要修改 filter.d 文件夹或 action.d 文件夹下的配置文件时,不要直接编辑 .conf 文件而应该创建一个同名的但以 .local 结尾的文件(如想要修改 nginx-http-auth.conf 的话就创建一个 nginx-http-auth.local)。这是因为当 actions 和 fileter 更新时,.conf 文件会被覆写而使修改失效。而 .local文件是追加到 .conf文件后面的,不受.conf文件的变动的影响(根据对 Dockerfile 文件的分析,这些 .conf 文件应该是在构建 Docker 镜像时下载的,所以更新镜像后即使复用原来的文件夹,.conf?文件也会被覆写)
  • 查看哪些 jail 是启用的
docker exec -it letsencrypt fail2ban-client status
  • 查看特定 jail 的状态
docker exec -it letsencrypt fail2ban-client status <jail name>
  • 设置特定 jail 对特定 IP 放行(注意:linuxserver/letsencrypt 给的教程没有 set ,会报指令错误。根据下面 fail2ban 的官方命令,我发现要加set)
docker exec -it letsencrypt fail2ban-client set <jail name> unbanip <IP>
3. 默认配置

查看 /config/fail2ban/jail.local 文件,部分内容如下:

[DEFAULT]
# "bantime" is the number of seconds that a host is banned.
bantime  = 600
# A host is banned if it has generated "maxretry" during the last "findtime"
# seconds.
findtime  = 600
# "maxretry" is the number of failures before a host get banned.
maxretry = 5

[nginx-http-auth]

enabled  = true
filter   = nginx-http-auth
port     = http,https
logpath  = /config/log/nginx/error.log

上方 [DEFAULT]?的含义:若在600秒内失败5次,则禁止访问600秒。
[nginx-http-auth] 的内容是启用,使用 nginx-http-auth 过滤器监听 HTTP 和 HTTPS 端口并把日志写在 /config/log/nginx/error.log 文件里。配置的选项则同[DEFAULT]。更多配置信息请看官方指南://www.fail2ban.org/wiki/index.php/MANUAL_0_8#General_settings

4. 测试

接下来当然是来测试一波啦。

先确保网页 HTTP 密码?;ご蚩?,然后登陆。任意错误登陆(用户名不能为空)5次后网页就开始提示找不到服务器了。

这个时候可以查看一下 jail 的状态,内容如下:

Total banned 表示历史 ban 总记录。在 Banned IP list 中可以看到 IP 已经被封了。

接下来再把 IP 解禁,如下:

可以查看 /config/log/fail2ban/fail2ban.log 文件:

这个是600秒后自动解禁的
2018-09-15 09:39:44,090 fail2ban.filter         [343]: INFO    [nginx-http-auth] Found 125.90.49.157 - 2018-09-15 09:39:44
2018-09-15 09:39:48,295 fail2ban.filter         [343]: INFO    [nginx-http-auth] Found 125.90.49.157 - 2018-09-15 09:39:48
2018-09-15 09:39:53,503 fail2ban.filter         [343]: INFO    [nginx-http-auth] Found 125.90.49.157 - 2018-09-15 09:39:53
2018-09-15 09:39:56,709 fail2ban.filter         [343]: INFO    [nginx-http-auth] Found 125.90.49.157 - 2018-09-15 09:39:56
2018-09-15 09:39:57,911 fail2ban.filter         [343]: INFO    [nginx-http-auth] Found 125.90.49.157 - 2018-09-15 09:39:57
2018-09-15 09:39:58,107 fail2ban.actions        [343]: NOTICE  [nginx-http-auth] Ban 125.90.49.157
2018-09-15 09:49:58,920 fail2ban.actions        [343]: NOTICE  [nginx-http-auth] Unban 125.90.49.157

这个是使用命令解禁的
2018-09-15 11:18:10,728 fail2ban.filter         [343]: INFO    [nginx-http-auth] Found 125.90.49.157 - 2018-09-15 11:18:10
2018-09-15 11:18:12,738 fail2ban.filter         [343]: INFO    [nginx-http-auth] Found 125.90.49.157 - 2018-09-15 11:18:12
2018-09-15 11:18:13,940 fail2ban.filter         [343]: INFO    [nginx-http-auth] Found 125.90.49.157 - 2018-09-15 11:18:13
2018-09-15 11:18:14,542 fail2ban.filter         [343]: INFO    [nginx-http-auth] Found 125.90.49.157 - 2018-09-15 11:18:14
2018-09-15 11:18:15,143 fail2ban.filter         [343]: INFO    [nginx-http-auth] Found 125.90.49.157 - 2018-09-15 11:18:14
2018-09-15 11:18:15,620 fail2ban.actions        [343]: NOTICE  [nginx-http-auth] Ban 125.90.49.157
2018-09-15 11:18:15,745 fail2ban.filter         [343]: INFO    [nginx-http-auth] Found 125.90.49.157 - 2018-09-15 11:18:15
2018-09-15 11:18:35,942 fail2ban.actions        [343]: NOTICE  [nginx-http-auth] Unban 125.90.49.157

参考文档

相关文章

]]>
//www.klh31.com/31072.html/feed 0
Java HashMap源码分析 - ★广西快3龙虎★ //www.klh31.com/31096.html //www.klh31.com/31096.html#comments Wed, 02 Jan 2019 08:14:33 +0000 唐尤华 //www.klh31.com/?p=31096

本文从 Hash 方法开始,通过分析源码,深入介绍了 JDK 不同版本中 HashMap 的实现。

HashMap 简介

HashMap 主要用来存放键值对,它基于哈希表的Map接口实现,是常用的Java集合之一。

JDK1.8 之前 HashMap 由 数组+链表 组成的,数组是 HashMap 的主体,链表则是主要为了解决哈希冲突而存在的(“拉链法”解决冲突).JDK1.8 以后在解决哈希冲突时有了较大的变化,当链表长度大于阈值(默认为 8)时,将链表转化为红黑树,以减少搜索时间。

底层数据结构分析

JDK1.8之前

JDK1.8 之前 HashMap 底层是?数组和链表?结合在一起使用也就是?链表散列。HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值,然后通过?(n - 1) & hash?判断当前元素存放的位置(这里的 n 指的是数组的长度),如果当前位置存在元素的话,就判断该元素与要存入的元素的 hash 值以及 key 是否相同,如果相同的话,直接覆盖,不相同就通过拉链法解决冲突。

所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使用扰动函数之后可以减少碰撞。

JDK 1.8 HashMap 的 hash 方法源码:

JDK 1.8 的 hash方法 相比于 JDK 1.7 hash 方法更加简化,但是原理不变。

static final int hash(Object key) {
  int h;
  // key.hashCode():返回散列值也就是hashcode
  // ^ :按位异或
  // >>>:无符号右移,忽略符号位,空位都以0补齐
  return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

对比一下 JDK1.7的 HashMap 的 hash 方法源码.

static int hash(int h) {
    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).

    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

相比于 JDK1.8 的 hash 方法 ,JDK 1.7 的 hash 方法的性能会稍差一点点,因为毕竟扰动了 4 次。

所谓?“拉链法”?就是:将链表和数组相结合。也就是说创建一个链表数组,数组中每一格就是一个链表。若遇到哈希冲突,则将冲突的值加到链表中即可。

JDK1.8之后

相比于之前的版本,jdk1.8在解决哈希冲突时有了较大的变化,当链表长度大于阈值(默认为8)时,将链表转化为红黑树,以减少搜索时间。

类的属性:

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
    // 序列号
    private static final long serialVersionUID = 362498820763181265L;    
    // 默认的初始容量是16
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;   
    // 最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30; 
    // 默认的填充因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    // 当桶(bucket)上的结点数大于这个值时会转成红黑树
    static final int TREEIFY_THRESHOLD = 8; 
    // 当桶(bucket)上的结点数小于这个值时树转链表
    static final int UNTREEIFY_THRESHOLD = 6;
    // 桶中结构转化为红黑树对应的table的最小大小
    static final int MIN_TREEIFY_CAPACITY = 64;
    // 存储元素的数组,总是2的幂次倍
    transient Node<k,v>[] table; 
    // 存放具体元素的集
    transient Set<map.entry<k,v>> entrySet;
    // 存放元素的个数,注意这个不等于数组的长度。
    transient int size;
    // 每次扩容和更改map结构的计数器
    transient int modCount;   
    // 临界值 当实际大小(容量*填充因子)超过临界值时,会进行扩容
    int threshold;
    // 填充因子
    final float loadFactor;
}
  • loadFactor加载因子

loadFactor加载因子是控制数组存放数据的疏密程度,loadFactor越趋近于1,那么 数组中存放的数据(entry)也就越多,也就越密,也就是会让链表的长度增加,load Factor越小,也就是趋近于0,

loadFactor太大导致查找元素效率低,太小导致数组的利用率低,存放的数据会很分散。loadFactor的默认值为0.75f是官方给出的一个比较好的临界值。

  • threshold

threshold = capacity * loadFactor,当Size>=threshold的时候,那么就要考虑对数组的扩增了,也就是说,这个的意思就是?衡量数组是否需要扩增的一个标准。

Node节点类源码:

// 继承自 Map.Entry<K,V>
static class Node<K,V> implements Map.Entry<K,V> {
       final int hash;// 哈希值,存放元素到hashmap中时用来与其他元素hash值比较
       final K key;//键
       V value;//值
       // 指向下一个节点
       Node<K,V> next;
       Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }
        // 重写hashCode()方法
        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
        // 重写 equals() 方法
        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
}

树节点类源码:

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // 父
        TreeNode<K,V> left;    // 左
        TreeNode<K,V> right;   // 右
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;           // 判断颜色
        TreeNode(int hash, K key, V val, Node<K,V> next) {
            super(hash, key, val, next);
        }
        // 返回根节点
        final TreeNode<K,V> root() {
            for (TreeNode<K,V> r = this, p;;) {
                if ((p = r.parent) == null)
                    return r;
                r = p;
       }

HashMap源码分析

构造方法

// 默认构造函数。
public More ...HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all   other fields defaulted
 }

 // 包含另一个“Map”的构造函数
 public More ...HashMap(Map<? extends K, ? extends V> m) {
     this.loadFactor = DEFAULT_LOAD_FACTOR;
     putMapEntries(m, false);//下面会分析到这个方法
 }

 // 指定“容量大小”的构造函数
 public More ...HashMap(int initialCapacity) {
     this(initialCapacity, DEFAULT_LOAD_FACTOR);
 }

 // 指定“容量大小”和“加载因子”的构造函数
 public More ...HashMap(int initialCapacity, float loadFactor) {
     if (initialCapacity < 0)
         throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
     if (initialCapacity > MAXIMUM_CAPACITY)
         initialCapacity = MAXIMUM_CAPACITY;
     if (loadFactor <= 0 || Float.isNaN(loadFactor))
         throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
     this.loadFactor = loadFactor;
     this.threshold = tableSizeFor(initialCapacity);
 }

putMapEntries方法:

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    int s = m.size();
    if (s > 0) {
        // 判断table是否已经初始化
        if (table == null) { // pre-size
            // 未初始化,s为m的实际元素个数
            float ft = ((float)s / loadFactor) + 1.0F;
            int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                    (int)ft : MAXIMUM_CAPACITY);
            // 计算得到的t大于阈值,则初始化阈值
            if (t > threshold)
                threshold = tableSizeFor(t);
        }
        // 已初始化,并且m元素个数大于阈值,进行扩容处理
        else if (s > threshold)
            resize();
        // 将m中的所有元素添加至HashMap中
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
            K key = e.getKey();
            V value = e.getValue();
            putVal(hash(key), key, value, false, evict);
        }
    }
}

put方法

HashMap只提供了put用于添加元素,putVal方法只是给put方法调用的一个方法,并没有提供给用户使用。

对putVal方法添加元素的分析如下:

  • ①如果定位到的数组位置没有元素 就直接插入。
  • ②如果定位到的数组位置有元素就和要插入的 key 比较,如果key相同就直接覆盖,如果 key 不相同,就判断 p 是否是一个树节点,如果是就调用?e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value)?将元素添加进入。如果不是就遍历链表插入。

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // table未初始化或者长度为0,进行扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    // (n - 1) & hash 确定元素存放在哪个桶中,桶为空,新生成结点放入桶中(此时,这个结点是放在数组中)
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 桶中已经存在元素
    else {
        Node<K,V> e; K k;
        // 比较桶中第一个元素(数组中的结点)的hash值相等,key相等
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
                // 将第一个元素赋值给e,用e来记录
                e = p;
        // hash值不相等,即key不相等;为红黑树结点
        else if (p instanceof TreeNode)
            // 放入树中
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        // 为链表结点
        else {
            // 在链表最末插入结点
            for (int binCount = 0; ; ++binCount) {
                // 到达链表的尾部
                if ((e = p.next) == null) {
                    // 在尾部插入新结点
                    p.next = newNode(hash, key, value, null);
                    // 结点数量达到阈值,转化为红黑树
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    // 跳出循环
                    break;
                }
                // 判断链表中结点的key值与插入的元素的key值是否相等
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    // 相等,跳出循环
                    break;
                // 用于遍历桶中的链表,与前面的e = p.next组合,可以遍历链表
                p = e;
            }
        }
        // 表示在桶中找到key值、hash值与插入元素相等的结点
        if (e != null) { 
            // 记录e的value
            V oldValue = e.value;
            // onlyIfAbsent为false或者旧值为null
            if (!onlyIfAbsent || oldValue == null)
                //用新值替换旧值
                e.value = value;
            // 访问后回调
            afterNodeAccess(e);
            // 返回旧值
            return oldValue;
        }
    }
    // 结构性修改
    ++modCount;
    // 实际大小大于阈值则扩容
    if (++size > threshold)
        resize();
    // 插入后回调
    afterNodeInsertion(evict);
    return null;
}

我们再来对比一下 JDK1.7 put方法的代码

对于put方法的分析如下:

  • ①如果定位到的数组位置没有元素 就直接插入。
  • ②如果定位到的数组位置有元素,遍历以这个元素为头结点的链表,依次和插入的key比较,如果key相同就直接覆盖,不同就采用头插法插入元素。
public V put(K key, V value)
    if (table == EMPTY_TABLE) { 
    inflateTable(threshold); 
}  
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) { // 先遍历
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue; 
        }
    }

    modCount++;
    addEntry(hash, key, value, i);  // 再插入
    return null;
}

get方法

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 数组元素相等
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        // 桶中不止一个节点
        if ((e = first.next) != null) {
            // 在树中get
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            // 在链表中get
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

resize方法

进行扩容,会伴随着一次重新hash分配,并且会遍历hash表中所有的元素,是非常耗时的。在编写程序中,要尽量避免resize。

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        // 超过最大值就不再扩充了,就只好随你碰撞去吧
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 没超过最大值,就扩充为原来的2倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    else { 
        signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 计算新的resize上限
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        // 把每个bucket都移动到新的buckets中
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { 
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        // 原索引
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        // 原索引+oldCap
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 原索引放到bucket里
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    // 原索引+oldCap放到bucket里
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

HashMap常用方法测试

package map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

public class HashMapDemo {

    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<String, String>();
        // 键不能重复,值可以重复
        map.put("san", "张三");
        map.put("si", "李四");
        map.put("wu", "王五");
        map.put("wang", "老王");
        map.put("wang", "老王2");// 老王被覆盖
        map.put("lao", "老王");
        System.out.println("-------直接输出hashmap:-------");
        System.out.println(map);
        /**
         * 遍历HashMap
         */
        // 1.获取Map中的所有键
        System.out.println("-------foreach获取Map中所有的键:------");
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.print(key+"  ");
        }
        System.out.println();//换行
        // 2.获取Map中所有值
        System.out.println("-------foreach获取Map中所有的值:------");
        Collection<String> values = map.values();
        for (String value : values) {
            System.out.print(value+"  ");
        }
        System.out.println();//换行
        // 3.得到key的值的同时得到key所对应的值
        System.out.println("-------得到key的值的同时得到key所对应的值:-------");
        Set<String> keys2 = map.keySet();
        for (String key : keys2) {
            System.out.print(key + ":" + map.get(key)+"   ");

        }
        /**
         * 另外一种不常用的遍历方式
         */
        // 当我调用put(key,value)方法的时候,首先会把key和value封装到
        // Entry这个静态内部类对象中,把Entry对象再添加到数组中,所以我们想获取
        // map中的所有键值对,我们只要获取数组中的所有Entry对象,接下来
        // 调用Entry对象中的getKey()和getValue()方法就能获取键值对了
        Set<java.util.Map.Entry<String, String>> entrys = map.entrySet();
        for (java.util.Map.Entry<String, String> entry : entrys) {
            System.out.println(entry.getKey() + "--" + entry.getValue());
        }

        /**
         * HashMap其他常用方法
         */
        System.out.println("after map.size():"+map.size());
        System.out.println("after map.isEmpty():"+map.isEmpty());
        System.out.println(map.remove("san"));
        System.out.println("after map.remove():"+map);
        System.out.println("after map.get(si):"+map.get("si"));
        System.out.println("after map.containsKey(si):"+map.containsKey("si"));
        System.out.println("after containsValue(李四):"+map.containsValue("李四"));
        System.out.println(map.replace("si", "李四2"));
        System.out.println("after map.replace(si, 李四2):"+map);
    }

}

参考文章

相关文章

]]>
//www.klh31.com/31096.html/feed 4
每周10道Java面试题:集合类 - ★广西快3龙虎★ //www.klh31.com/31039.html //www.klh31.com/31039.html#comments Tue, 01 Jan 2019 06:06:08 +0000 唐尤华 //www.klh31.com/?p=31039

每周10道?Java?面试题由 ImportNew 整理编译自网络。
面试题答案讨论请移步:https://github.com/jobbole/java-interview/issues/1
Java面试题投递交流请移步:https://github.com/jobbole/java-interview/issues/2

1. 你了解哪些集合类型?

答案:你应该知道以下几个最重要的类型:

  • ArrayList
  • LinkedList
  • HashMap
  • HashSet

之后,你可能会被问到这样一些问题,比如应该何时使用此种特定类型,它比其他的好在哪里,它是怎么存储数据的以及隐匿在背后的数据结构是什么。最好的方法是尽可能多地了解这些集合类型,因为这类问题几乎是无穷尽的。

2. HashMap 有什么特点?
答案:HashMap 基于Map接口实现,存储键值对时,可以接收 null 为键值。HashMap 是非同步的。

3. HashMap 的工作原理是怎样的?
答案:HashMap 在 Map.Entry 静态内部类实现中存储键值对,使用哈希算法。在 put 和 get 方法中,使用 hashCode() 和 equals() 方法。

  • 调用 put 方法时,使用键值对中的 Key hashCode() 和哈希算法找出存储键值对索引。键值对 Entry 存储在 LinkedList 中,如果存在 Entry,使用 equals() 方法来检查 Key 是否已经存在:如果存在,则覆盖 value;如果不存在,会创建一个新的 Entry 然后保存。
  • 调用 get 方法时,HashMap 使用键值 Key hashCode() 来找到数组中的索引,然后使用 equals() 方法找出正确的 Entry,返回 Entry 中的 Value。

分析:HashMap 中容量、负荷系数和阀值是重要的参数。HashMap 默认的初始容量是16,负荷系数是0.75。阀值 = 负荷系数 x 容量。添加 Entry时,如果 Map 的大小 > 阀值,HashMap 会对 Map 的内容重新哈希,使用更大的容量(容量总是2的幂)。关于 JDK 中的 hash 算法实现以及由此引发的哈希碰撞现象(DDos攻击)都可能是面试的延伸问题。

更新:HashMap初始容量16,static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

4. 能否使用任何类作为 Map 的 key?

答案:可以使用任何类作为 Map 的 key,然而在使用之前,需要考虑以下几点:

  • 如果类重写了 equals() 方法,也应该重写 hashCode() 方法。
  • 类的所有实例需要遵循与 equals() 和 hashCode() 相关的规则。
  • 如果一个类没有使用 equals(),不应该在 hashCode() 中使用它。
  • 用户自定义 Key 类最佳实践是使之为不可变的,这样 hashCode() 值可以被缓存起来,拥有更好的性能。不可变的类也可以确保 hashCode() 和 equals() 在未来不会改变,这样就会解决与可变相关的问题了。

分析:如果有一个类 MyKey,在 HashMap 中使用它:

HashMap<MyKey, String> myHashMap = new HashMap<MyKey, String>();

//传递给 MyKey 的 name 参数被用于 equals() 和 hashCode() 中
MyKey key = new MyKey("Pankaj"); // 假设 hashCode=1234
myHashMap.put(key, "Value");

// 以下的代码会改变 key 的 hashCode() 和 equals() 值
key.setName("Amit"); // 假设新的 hashCode=7890

//下面会返回 null,因为 HashMap 会尝试查找存储同样索引的 key,而 key 已被改变了,匹配失败,返回 null
System.out.println(myHashMap.get(new MyKey("Pankaj")));

这就是为什么 String 通?;嵊米?HashMap 的 Key,因为 String 的设计是不可变的(immutable)。

5.?插入数据时,ArrayList、LinkedList、Vector谁速度较快?
答案:ArrayList、Vector 底层的实现都是使用数组方式存储数据。数组元素数大于实际存储的数据以便增加和插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存操作,所以索引数据快而插入数据慢。

  • Vector 中的方法由于加了 synchronized 修饰,因此 Vector 是线程安全容器,但性能上较ArrayList差。
  • LinkedList 使用双向链表实现存储,按序号索引数据需要进行前向或后向遍历,但插入数据时只需要记录当前项的前后项即可,所以 LinkedList?插入速度较快。

6. 多线程场景下如何使用 ArrayList?
答案:
ArrayList 不是线程安全的,如果遇到多线程场景,可以通过 Collections 的 synchronizedList 方法将其转换成线程安全的容器后再使用。例如像下面这样:

List<String> synchronizedList = Collections.synchronizedList(list);
synchronizedList.add("aaa");
synchronizedList.add("bbb");
for (int i = 0; i < synchronizedList.size(); i++)
{
    System.out.println(synchronizedList.get(i));
}

7. 说一下 ArrayList 的优缺点
答案:ArrayList的优点如下:

  1. ArrayList 底层以数组实现,是一种随机访问模式。ArrayList?实现了 RandomAccess 接口,因此查找的时候非???。
  2. ArrayList 在顺序添加一个元素的时候非常方便。

ArrayList 的缺点如下:

  1. 删除元素的时候,需要做一次元素复制操作。如果要复制的元素很多,那么就会比较耗费性能。
  2. 插入元素的时候,也需要做一次元素复制操作,缺点同上。

ArrayList 比较适合顺序添加、随机访问的场景。

8.?为什么 ArrayList 的 elementData 加上 transient 修饰?
答案:ArrayList 中的数组定义如下:

private transient Object[] elementData;

再看一下 ArrayList 的定义:

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

可以看到 ArrayList 实现了 Serializable 接口,这意味着 ArrayList 支持序列化。transient 的作用是说不希望 elementData 数组被序列化,重写了?writeObject 实现:

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
	// Write out element count, and any hidden stuff
	int expectedModCount = modCount;
	s.defaultWriteObject();
        // Write out array length
	s.writeInt(elementData.length);
        // Write out all elements in the proper order.
	for (int i=0; i<size; i++)
	    s.writeObject(elementData[i]);
	if (modCount != expectedModCount) {
	    throw new ConcurrentModificationException();
	}

每次序列化时,先调用 defaultWriteObject() 方法序列化 ArrayList 中的非 transient 元素,然后遍历 elementData,只序列化已存入的元素,这样既加快了序列化的速度,又减小了序列化之后的文件大小。

9.?遍历一个 List 有哪些不同的方式?每种方法的实现原理是什么?Java 中 List 遍历的最佳实践是什么?
答案:
遍历方式有以下几种:

  1. for 循环遍历,基于计数器。在集合外部维护一个计数器,然后依次读取每一个位置的元素,当读取到最后一个元素后停止。
  2. 迭代器遍历,Iterator。Iterator 是面向对象的一个设计模式,目的是屏蔽不同数据集合的特点,统一遍历集合的接口。Java 在 Collections 中支持了 Iterator 模式。
  3. foreach 循环遍历。foreach 内部也是采用了 Iterator 的方式实现,使用时不需要显式声明 Iterator 或计数器。优点是代码简洁,不易出错;缺点是只能做简单的遍历,不能在遍历过程中操作数据集合,例如删除、替换。

最佳实践:Java Collections?框架中提供了一个 RandomAccess 接口,用来标记 List 实现是否支持 Random Access。

  • 如果一个数据集合实现了该接口,就意味着它支持 Random Access,按位置读取元素的平均时间复杂度为 O(1),如ArrayList。
  • 如果没有实现该接口,表示不支持 Random Access,如LinkedList。

推荐的做法就是,支持 Random Access 的列表可用 for 循环遍历,否则建议用 Iterator 或 foreach 遍历。

10.?如何边遍历边移除 Collection 中的元素?
答案:
边遍历边修改 Collection 的唯一正确方式是使用?Iterator.remove()?方法,如下:

Iterator<Integer> it = list.iterator();
while(it.hasNext()){
    // do something
    it.remove();
}

一种最常见的错误代码如下:

for(Integer i : list){
    list.remove(i)
}

运行以上错误代码会报?ConcurrentModificationException?异常。这是因为当使用?foreach(for(Integer i : list)) 语句时,会自动生成一个iterator 来遍历该 list,但同时该 list 正在被?Iterator.remove()?修改。Java 一般不允许一个线程在遍历 Collection 时另一个线程修改它。

相关文章

]]>
//www.klh31.com/31039.html/feed 3
ImportNew一周资讯:2019软件趋势 - ★广西快3龙虎★ //www.klh31.com/30942.html //www.klh31.com/30942.html#comments Mon, 31 Dec 2018 02:27:53 +0000 唐尤华 //www.klh31.com/?p=30942

ImportNew小编为您搜集有关Java业界、资源一周资讯(2018.12.31)。
(内容无特殊说明均为英文,这里仅做摘编,点击链接可直达原文。)

1. 2019软件趋势:来自 pivotal
解读:
又到了一年总结和展望的时候了,看看 Pivotal(Spring)公司带来的2019年软件趋势关键词。

  • ?敏捷
  • 人工智能应用和机器学习
  • 区块链
  • 容器
  • 数据
  • 设计
  • 医疗
  • IT现代化及改造
  • Kubernetes
  • 微服务
  • 开源
  • 零售
  • 安全
  • Serverless
  • 软件工程师

每个主题都邀请了资深的专家进行解读,完整内容可点击原文查看。

2. Java 还是免费的:来自 javaadvent

解读:自从 Oracle 宣布了有关 Java 的一些重大计划,关于 Java 未来是否免费使用这个问题网上有很多讨论。这篇文章做了详细的总结:

  • 正在使用 Java SE8,又想未来免费使用,该怎么做?2019 年以后,Oracle Java SE8 的不是免费更新了。这时,可以选择 OpenJDK,比如Linux 发行版、AdoptOpenJDK、Azul、IBM、Red Hat 或其他版本。
  • 正在使用 Java SE11,又想未来免费使用,该怎么做?可以有两种选择:使用 Oracle OpenJDK 遵循(GPLv2+CE)开源协议,或者选择 OpenJDK,比如Linux 发行版、AdoptOpenJDK、Azul、IBM、Red Hat等其他版本。
3. Java 11: HTTP Client 新API:来自 javacodegeeks
解读:Java 9 里引入的 HTTP Client 新 API,在 Java 11 里成为了标准 API。这篇文章通过例子介绍了新 API 的特性,连接?URL 的代码更简单,可以方便地管理请求参数、cookie 和 session,支持异步请求与 WebSocket。

4. 在 Ubuntu 18.04 上安装真的 OpenJDK 11:来自 javacodegeeks
解读:2018年9月25日,OpenJDK 11 发布了,安装的软件名称 openjdk-11-jdk,这是 OpenJDK 8 版本之后首个 LTS 版本。作者安装后发现,OpenJDK 11 看起来还是预览版(JDK 10)。通过命令安装,

% apt-get install default-jdk

version 参数给出的版本是 10.0.2。
要真的安装 OpenJDK 11 还是要下载后手动安装。

$ /usr/lib/jvm/jdk-11/bin/java -version
openjdk version "11" 2018-09-25
OpenJDK Runtime Environment 18.9 (build 11+28)
OpenJDK 64-Bit Server VM 18.9 (build 11+28, mixed mode)

5.?Java: 堆外内存中的聚合数据:来自?javacodegeeks
解读:
文章介绍了针对大量堆外内存(off-heap)中的聚合数据,最小化垃圾回收带来的影响,同时最大提升内存利用率。作者给出的答案是?Speedment Stream ORM(https://www.speedment.com/initializer/),声称可以做到提高内存利用同时对垃圾回收几乎没有影响。
文章中通过一个例子介绍了 Speedment API 的使用。
从 Speedment API 官网白皮书和演示视频中了解到,该项目主要目标是通过改进框架提升访问 ORM 效率。ORM 是核心产品,超过一定数据量(500M)会收费。Speedment 聚合 API 是 ORM 底层技术的一部分。

6. Eclipse Collections 的隐藏福利:来自 javacodegeeks
解读:
Eclipse Collections 是一个开源集合框架,这篇文章介绍了几个虽不常用但很强大的 API,distinct()、partition()、selectInstancesOf()、chunk()、as vs to 命名规范。

  • distinct():找出 List 中唯一的元素通常用到 Set,但这么干会丧失原有的序列,distinct 可以解决这个问题
  • partition():对传入列表通过 Predicate 一次性处理(选择或拒绝)
  • selectInstancesOf():对传入列表过滤属于某个 class 的实例
  • chunk():按照指定的列表大小拆分 iterable 输入,得到子集合
  • 用 as vs to 命名 API:更好地遵守 Java 方法命名规范,https://blog.joda.org/2011/08/common-java-method-names.html

7. Java: 把 JDBC ResultSet 转为 CSV:来自 javacodegeeks
解读:这是一段实用的小例子,作者介绍了如何把 JDBC ResultSet 转成了 CSV。不仅如此,还有 ResultSet 转 JSON。
GitHub地址:https://github.com/sharfah/java-utils/tree/master/src/main/java/com/sharfah/util/sql

相关文章

]]>
//www.klh31.com/30942.html/feed 1
每周10道Java面试题:String, String Pool, StringBuilder - ★广西快3龙虎★ //www.klh31.com/31022.html //www.klh31.com/31022.html#comments Sun, 23 Dec 2018 15:45:09 +0000 唐尤华 //www.klh31.com/?p=31022

每周10道?Java?面试题由 ImportNew 整理编译自网络。
面试题答案讨论请移步:https://github.com/jobbole/java-interview/issues/1
Java面试题投递交流请移步:https://github.com/jobbole/java-interview/issues/2

1. 写出下面代码的运行结果。

int src = 65536;
Integer dst = new Integer(65536);
System.out.println(src == dst);
System.out.println(dst.equals(src));

答案:true true
考点:Integer 的 equals 实现。查看源代码可以发现,65536 装箱为 Integer 对象后,dst.equals 方法比较的是 obj.intValue。

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

2. 写出下面代码执行结果。

// 1. 打印 null String
String s = null;
System.out.println(s);

// 2. 打印 null Integer
Integer i = null;
System.out.println(i);

// 3. 打印 str
String str = null;
str = str + "!";
System.out.println(str);

答案:

null
null
null!

考点:打印函数?print 与字符串拼接函数对 null 都进行了特殊处理,因此不会出现运行时异常,而是输入出 “null” 字符串。
细节分析可参见 Importnew:Java String 对 null 对象的容错处理?一文。

3. 写出下面代码的运行结果。

public class Example {
    private static void sayHello() {
        System.out.println("Hello");
    }

    public static void main(String[] args) {
        ((Example)null).sayHello();
    }
}

答案:Hello
考点:null 作为非基本类型,可以做类型转换,转换后调用静态方法输出字符串?;纠嘈?,比如 int,类型转换时会报告空指针异常,比如 int a = (Integer)null; 原因就是转换过程中会调用?intValue(),因此会报告异常。

4.?String类能被继承吗,为什么?

答案:不能。因为 String 类的定义为 final class,被 final 修饰的类不能被继承。

public final class String

考点:String 对象不可变的(immutable)。分析为什么要这么设计,可能有以下3个原因:

  • String pool:这是方法(method)区域里一个特殊的存储区域,创建一个 String 时,如果已经在 String pool 中存在,那么会返回已存在的 String 引用。
  • 允许 String 缓存 hashcode:String 定义中,有 hash 成员变量 private int hash; // 默认为0,对 hashcode 进行缓存。
  • 安全性:确保不会被恶意篡改。

5. 写出下面代码的运行结果。

String s1 = "Cat";
String s2 = "Cat";
String s3 = new String("Cat");

System.out.println("s1 == s2 :"+(s1==s2));
System.out.println("s1 == s3 :"+(s1==s3));

答案:

s1 == s2 :true
s1 == s3 :false

考点:理解?String pool,s1 与 s2 字符串内容相同,因此直接从 String pool 中返回相同的地址。s3 会创建一个新的 String 对象,因此 s1==s3 结果返回 false。

6.?String s3 = new String(“Cat”) 这句代码会创建几个 String 对象?

答案:1 或 2 个。

考点:理解?String pool 机制。如果 Spring pool 在执行语句之前没有 “Cat” 对象,那么会创建 2 个 String;反之只创建 1 个 String 对象,”Cat” 会从 String pool 中直接返回对象。

7.?String、StringBuffer、StringBuilder的区别?

答案:有以下区别:

  1. String 是不可变的,StringBuffer、StringBuilder 是可变的;
  2. String 、StringBuffer 是线程安全的,StringBuilder 不是线程安全的。
  3. StringBuilder 相较于 StringBuffer 有速度优势,所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下,则必须使用 StringBuffer 类。

8. 如何比较两个字符串?使用 “==” 还是 equals() 方法?

答案:简单来讲,“==” 测试的是两个对象的引用是否相同,而equals()比较的是两个字符串的值是否相等。除非你想检查的是两个字符串是否是同一个对象,否则你应该使用 equals() 来比较字符串。

用之前的例子:

String s1 = "Cat";
String s3 = new String("Cat");

System.out.println("s1 == s3 :"+(s1==s3));
System.out.println("s1.equals(s3) :"+(s1.equals(s3)));

运行结果:

s1 == s3 :false
s1.equals(s3) :true

9. 为什么针对安全保密高的信息,char[] 比 String 更好?

答案:因为String是不可变的,就是说它一旦创建,就不能更改了,直到垃圾收集器将它回收。而字符数组中的元素是可以更改的,这就意味着你可以在使用完之后将其更改,而不会保留原始数据。所以使用字符数组的话,安全保密性高的信息,如密码之类信息,将不会存在于系统中被他人看到。

10. 可以针对字符串使用 switch 条件语句吗?

答案:JDK 7 及更新版本可以,在JDK 6或者之前的版本,则不能使用 switch 条件语句。

相关文章

]]>
//www.klh31.com/31022.html/feed 3
ImportNew一周资讯:JDK 9, 10与11中的安全改进 - ★广西快3龙虎★ //www.klh31.com/31011.html //www.klh31.com/31011.html#comments Sun, 23 Dec 2018 13:21:50 +0000 唐尤华 //www.klh31.com/?p=31011

ImportNew小编为您搜集有关Java业界、资源一周资讯(2018.12.24)。
(内容无特殊说明均为英文,这里仅做摘编,点击链接可直达原文。)

1. JDK 9, 10 与 11 中的安全改进:来自 javaadvent

解读:TLS 握手流程有以下9步:

  1. 客户端:发送”hello”(TLS版本、密码)
  2. 服务器:发送”hello”(服务器证书、TLS版本、密码)
  3. 客户端:验证服务器证书及加密参数
  4. 客户端:发送客户端证书
  5. 客户端:发送秘钥
  6. 服务器:验证客户端证书
  7. 客户端:结束
  8. 服务器:结束
  9. 客户端与服务器开始交换信息

JDK9 中的安全改进:JSSE(Java Secure Socket Extension) API

  • 支持 DTLS,在 UDP 上进行 TLS 加密
  • 加入 TLS ALPN 扩展,支持在 TLS 握手过程中加入应用协议
  • 对 TCP 进行 OCSP 加固,在 TLS 服务器上进行协议验证,节省带宽。此配置需要在客户端和服务器上同时启用
  • 默认使用 PKCS12 秘钥库:目前使用的 JKS 无法应用到 Java 以外的编程语言
  • 基于 DRBG 实现 SecureRandom
  • 利用 CPU 指令进行 GHASH 与 RSA 加密
  • 协议验证中禁用 SHA-1 协议
  • 实现 SHA-3 哈希算法

JDK10 中的安全改进:

  • JEP319 Root 证书:在 JDK 的 Cacert 秘钥库中加入 root 证书列表
  • 一些安全相关的 API 标记为移除

JDK 11 中的安全改进:

  • JEP32:TLS 1.3,在1.2版本基础上增加了许多改进
  • JDK 的 Cacert 秘钥库中增加了一些、移除了一些 root 证书

2. 用 Java 实现数据库批量更新:来自 javaadvent

解读:批量更新可以获得更好的执行效率。这篇文章介绍了如何通过 JDBC API、Spring JDBCTEMPLATE、JOOQ、Hibernate 实现批量更新。

3. 连接池你造吗:来自?javaadvent

解读:传统 Web 访问存在这样的问题,打开慢,忘记关闭连接会造成内存泄漏。使用数据库连接池是一种改进方法,比如 C3P0 (https://www.mchange.com/projects/c3p0/)、HikariCP (https://github.com/brettwooldridge/HikariCP)。那么问题来了,这些连接池解决方案好使吗?这篇文章对比了 C3P0 和 HikariCP 默认值使用情况,最后的结论是“别相信我,也不要相信默认值”。

4. Java8 默认方法介绍以及对 API 设计的影响:来自?javaadvent

解读:在引入默认方法之前,要为 interface 添加实现,必须通过 abstract 类再进行继承。这么做的问题,以 java.util 中的 List 为例,会造成不符合面向对象的设计,比如 static sort() 方法。Java8 引入的默认方法提供了新的解决方法,通过在 List 接口中加入 sort() 方法改进了 API 设计。

5. Eclipse Collection 编程练习的19种解答:来自?javaadvent

解读:Eclipse Collection(https://github.com/eclipse/eclipse-collections) Java 集合框架对 List、Set 和 Map 进行了优化,提供一套丰富的流式 API。这篇文章中,按照教程 //eclipse.github.io/eclipse-collections-kata/pet-kata/#/ 给出了19种解答。

6. Java 安全 API 动画演示:来自?javaadvent

解读:Java 安全动画(Security Animated)项目是一个通过动画、代码段介绍 Java 安全的开源项目 https://github.com/martinfmi/java_security_animated。内容涵盖 JDK 安全沙箱模型、JDK 安全开发库、主流框架安全机制(例如 OSGi,、JavaEE、Spring)及安全开发库 (如 BouncyCastle)。

整个演示包含以下章节:

- sanbox model
- security APIs:
	- JAAS
	- JSSE (SSL/TLS/DTLS)
	- GSSAPI/Kerberos
	- JCA (JCE/Crypto)
	- SASL
	- PKI (CertPath)
	- JAR Verification
	- XML Signatures
- tools: 
	- keytool
	- jarsigner
	- policytool
	- kinit
	- klist
	- ktabs

说明:项目 pom.xml 不全,可以关注 issue 解决进展。

相关文章

]]>
//www.klh31.com/31011.html/feed 0
Java中的构造函数引用和方法引用 - ★广西快3龙虎★ //www.klh31.com/30974.html //www.klh31.com/30974.html#comments Wed, 19 Dec 2018 06:34:09 +0000 Mr.Dcheng //www.klh31.com/?p=30974 JDK 8 见证了一个特殊特性的出现:构造函数引用和方法引用。在本文中, Adrian D. Finlay 探讨了开发人员如何释放构造函数引用的真正潜力。

方法引用的一些背景

如果你还不知道 Java 构造函数本身就是特殊的方法,那么阅读方法引用的基本示例将对读者有所帮助,通过了解这些内容,可以了解构造函数引用是什么。

「方法引用为已经有名称的方法提供易读的 lambda 表达式?!?/p>

「它们提供了一种无需执行就可以引用方法的简单方式?!?/p>

以上引自《Java 8 编程参考官方教程(第 9 版)》,作者:Herbert Schildt

译注:该书的第 8 版中文译本名称为:《Java 完全参考手册(第 8 版)》,第 9 版中文译本名称为:《Java 8 编程参考官方教程(第 9 版)》

方法引用可以引用静态方法和实例方法,两者是通用的。方法引用是函数式接口的实例。虽然 Lambda 表达式允许你动态创建方法实现,但通常情况下,一个方法最终会调用 Lambda 表达式中的另一个方法来完成我们想要完成的工作。更直接的方法是使用方法引用。当你已经有一个方法来实现这个函数式接口时,这是非常有用的。

让我们看一个使用静态方法及实例方法的示例。

//step #1 - Create a funnctional interface.
interface FuncInt {
    //contains one and only abstract method
    String answer(String x, boolean y);
}

//step #2 - Class providing method(s)that match FuncInt.answer()'s definition.
class Answer {
    static String ans_math_static(String x, Boolean y) {
        return "\"" + x + "\"" + "\t = \t" + y.toString().toUpperCase();
    }

    String ans_math_inst(String x, Boolean y) {
        return "\"" + x + "\"" + "\t = \t" + y.toString().toUpperCase();
    }
}

译注:以上代码的测试用例如下,因静态方法与实例方法结果相同,仅以静态方法为例。

Answer.ans_math_static("9 > 11 ?", false);
Answer.ans_math_static("987.6 < 1.1 ?", false);
Answer.ans_math_static("1 > 0.9 ?", true);
Answer.ans_math_static("T/F: Is Chengdu in Sichuan?", true);
Answer.ans_math_static("-1 % 0.2=0 ?", false);
Answer.ans_math_static("T/F: Does Dwyne Wade play for the Knicks?", false);

得到与原文举例相同的输出结果:

"9 > 11 ?"	 = 	FALSE
"987.6 < 1.1 ?"	 = 	FALSE
"1 > 0.9 ?"	 = 	TRUE
"T/F: Is Chengdu in Sichuan?"	 = 	TRUE
"-1 % 0.2=0 ?"	 = 	FALSE
"T/F: Does Dwyne Wade play for the Knicks?"	 = 	FALSE

另请参阅:关于var的所有内容:局部变量类型推断如何清除Java代码冗余

使用方法引用的主要步骤有:

  1. 定义一个函数式接口
  2. 定义一个满足函数式接口抽象方法要求的方法
  3. 使用对步骤2中定义的?(x :: y ) 方法引用实例化函数式接口的实例。
    译注:静态方法的方法引用格式为?类名 :: 方法名?;实例方法的方法引用格式为?对象实例名 :: 方法名?。
  4. 使用函数式接口实例调用方法:?Instance.AbstractMethod();

这提供了一种创建方法实现的可插拔方式。Lambda 表达式和方法引用为 Java 编程带来了一个功能方面的提升。

另请参阅:你到底有多了解Java的注解?

构造函数的方法引用

让我们开始详细讨论吧。

构造函数和其他方法一样是方法。对吗?错。它们有点特殊,它们是对象初始化方法。尽管如此,它们仍然是一个方法,没有什么能阻止我们像其他方法引用一样创建构造函数的方法引用。

//step #1 - Create a funnctional interface.
interface FuncInt {
    //contains one and only abstract method
    Automobile auto(String make, String model, short year);
}

//step #2 - Class providing method(s)that match FuncInt.answer()'s definition.
class Automobile {

    //Trunk Member Variables
    private String make;
    private String model;
    private short year;

    //Automobile Constructor
    public Automobile(String make, String model, short year) {
        this.make = make;
        this.model = model;
        this.year = year;
    }

    protected void what() {
        System.out.println("This Automobile is a" + year + " " + make + " " + model + ".");
    }
}

//Step #3 - Class making use of method reference
public class ConstrRef {

    static void createInstance() {
    }

    public static void main(String[] args) {
        System.out.println();

        //Remember, a Method Reference is an instance of a Functional Interface. Therefore....
        FuncInt auto = Automobile::new;//We really don't gain much from this example

        //Example #1
        Automobile honda = auto.auto("honda", "Accord", (short) 2006);
        honda.what();

        //Example #1
        Automobile bmw = auto.auto("BMW", "530i", (short) 2006);
        bmw.what();

        System.out.println();
    }
}

输出结果

This Automobile is a2006 honda Accord.
This Automobile is a2006 BMW 530i.

说明

用户应该清楚的第一件事是这个基本示例没有那么实用。这是一种相当迂回的创建对象实例的方式。实际上,几乎可以肯定,你不会经历所有这些麻烦来创建一个 Automobile 实例,但是为了概念的完整性,还是要提及。

使用构造函数的方法引用的主要步骤有:

  1. 定义一个只有抽象方法的函数式接口,该方法的返回类型与你打算使用该对象进行构造函数引用的对象相同。
  2. 创建一个类,该类的构造函数与函数式接口的抽象方法匹配。
  3. 使用对步骤 #2 中定义的构造函数的方法引用,实例化函数式接口的实例。
    译注:构造函数的方法引用格式为?类名 :: new
  4. 在步骤 #2 中使用构造函数引用实例化类的实例,例如?MyClass x = ConstructorReference.AbstractMethod (x, y, z…)

构造函数引用与泛型一起使用的时候变得更有用。通过使用泛型工厂方法,可以创建各种类型的对象。

让我们看一看。

//step #1 - Create a funnctional interface.
interface FuncInt<Ob, X, Y, Z> {
    //contains one and only abstract method
    Ob func(X make, Y model, Z year);
}

//step #2 - Create a Generic class providing a constructor compatible with FunInt.func()'s definition
class Automobile<X, Y, Z> {

    //Automobile Member Variables
    private X make;
    private Y model;
    private Z year;

    //Automobile Constructor
    public Automobile(X make, Y model, Z year) {
        this.make = make;
        this.model = model;
        this.year = year;
    }

    protected void what() {
        System.out.println("This Automobile is a " + year + " " + make + " " + model + ".");
    }
}

//step #3 - Create a Non-Generic class providing a constructor compatible with FunInt.func()'s definition
class Plane {

    //Automobile Member Variables
    private String make;
    private String model;
    private int year;

    //Plane Constructor
    public Plane(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;//Automatic unboxing
    }

    protected void what() {
        System.out.println("This Plane is a " + year + " " + make + " " + model + ".");
    }
}

//Step #3 - Class making use of method reference with generics
public class ConstrRefGen {

    //Here is where the magic happens
    static <Ob, X, Y, Z> Ob factory(FuncInt<Ob, X, Y, Z> obj, X p1, Y p2, Z p3) {
        return obj.func(p1, p2, p3);
    }

    public static void main(String[] args) {
        System.out.println();

        //Example #1
        FuncInt<Automobile<String, String, Integer>, String, String, Integer> auto_cons = Automobile<String, String, Integer>::new;
        Automobile<String, String, Integer> honda = factory(auto_cons, "Honda", "Accord", 2006);
        honda.what();

        //Example #2
        FuncInt<Plane, String, String, Integer> plane_cons = Plane::new;
        Plane cessna = factory(plane_cons, "Cessna", "Skyhawk", 172);
        cessna.what();

        System.out.println();
    }
}

输出结果

This Automobile is a 2006 Honda Accord.
This Plane is a 172 Cessna Skyhawk.

另请参阅:Java 中的 struct :如何像专业人士一样处理它们

说明

这里有很多东西需要消化。事实上,如果你以前从未深入研究过泛型,那么这些代码看上去可能相当晦涩。让我们分解一下。

我们做的第一件事是创建一个通用的函数式接口。注意细节。我们有四个泛型类型参数:Ob、X、Y、Z。

  • Ob 代表要引用其构造函数的类。
  • X,Y,Z 代表该类的构造函数的参数。

如果我们替换泛型方法占位符,抽象方法可能是这样的:?SomeClass func (String make, String model, int year)。注意,由于我们使接口具有了泛型,所以可以指定任何返回类型或我们希望返回的类实例。这释放了构造函数引用的真正潜力。

接下来的两个部分相对简单,我们创建了相同的类,一个泛型类和一个非泛型类,以演示它们与在公共类中定义的工厂方法的互操作性。注意,这些类的构造函数与?FuncInt.func()?的方法签名是兼容的。

进入公共类的文件。这个方法就是奇迹发生的地方。

//Here is where the magic happens
static <Ob, X, Y, Z> Ob factory(FuncInt<Ob, X, Y, Z> obj, X p1, Y p2, Z p3) {
    return obj.func(p1, p2, p3);
}

我们将该方法标记为静态的,所以我们可以不使用 ConstRefGen 实例,毕竟它是一个工厂方法。注意,factory 方法具有与函数式接口相同的泛型类型参数。注意,方法的返回类型是 Ob,它可以是由我们决定的任何类。当然,X、Y、Z是 Ob 中方法的方法参数。请注意,该函数以 FuncInt 的一个实例作为参数(类类型和方法参数作为类型参数),同时也接受 Ob 类型的类作为方法的参数。

另请参阅:Reactor.js:用于响应式编程的轻量级库

在方法体中,它调用方法引用并将在?factory()?中传递的参数提供给它。

我们的第一个任务是创建一个符合?FuncInt<>?的方法引用。

这里我们分别引用 Automobile 类和 Plane 类的构造函数。

我们的下一个任务是创建一个带有方法引用的对象。

为此,我们调用?factory()?并将它需要的构造函数引用以及?factory()?定义的有关构造函数的参数提供给它。factory()?可以灵活地创建对各种方法的构造函数引用,因为它是通用的。因为 Plane 类和 Automobile 类的构造函数匹配?FuncInt.func()?的方法签名,所以它们可作为?FuncInt.func()?的方法引用使用。factory()?通过调用?obj.func(x,y,z)?返回类的一个实例,这是一个构造函数方法引用,当求值时,它将为你提供指定为其参数的类的一个实例。

斟酌这个问题一段时间,会发现它是Java的一个非常有用的补充?;)

相关文章

]]>
//www.klh31.com/30974.html/feed 0
常被问到的十个 Java 面试题 - ★广西快3龙虎★ //www.klh31.com/30956.html //www.klh31.com/30956.html#comments Wed, 19 Dec 2018 05:58:48 +0000 ZIDANE //www.klh31.com/?p=30956 在这篇文章中,我试图收录最有趣和最常见的问题。此外,我将为您提供正确的答案。

接下来,就让我们来看看这些问题。

1. 以满分十分来评估自己——你有多擅长 Java?

如果你并不完全确信你自己或是你对 Java 的熟练程度,那么这会是一个非常棘手的问题。如果有这种情况,你应该把打分调低一点。之后,你大概会得到与你承认的水平相符的问题。因此,假如你给自己满分,却不能回答一个有点难的问题,那将会对你不利。

2. 阐述 Java 7 和 Java 8 的区别。

实话说,两者有很多不同。如果你能列出最重要的,应该就足够了。你应该解释 Java 8 中的新功能。想要获得完整清单,请访问官网:Java 8 JDK。

你应该知道以下几个重点:

  • lambda 表达式,Java 8 版本引入的一个新特性。lambda 表达式允许你将功能当作方法参数或将代码当作数据。lambda 表达式还能让你以更简洁的方式表示只有一个方法的接口 (称为函数式接口) 的实例。
  • 方法引用,为已命名方法提供了易于阅读的 lambda 表达式。
  • 默认方法,支持将新功能添加到类库中的接口,并确保与基于这些接口的旧版本的代码的二进制兼容性。
  • 重复注解,支持在同一声明或类型上多次应用同一注解类型。
  • 类型注解,支持在任何使用类型的地方应用注解,而不仅限于声明。此特性与可插入型系统一起使用时,可增强对代码的类型检查。

3. 你了解哪些集合类型?

你应该知道以下几个最重要的类型:

  • ArrayList
  • LinkedList
  • HashMap
  • HashSet

之后,你可能会被问到这样一些问题,比如何时应该使用此种特定类型,它比其他的好在哪里,它是怎么存储数据的以及隐匿在其后的数据结构是什么。

最好的方法是尽可能多地了解这些集合类型,因为这类问题几乎是无穷尽的。

4. Object 类包含哪些方法?

这是一个非常常见的问题,用来确定你对基础知识的熟悉程度。以下是每个对象都具有的方法:

在?java.lang?包中,Object?类位于类层次结构的顶端。每个类都是?Object?类直接或间接的子类。你使用或编写的每个类都继承了?Object?类中的实例方法。你并不需要使用这些方法中的任何一种,但是,如果你选择这样做,则可能需要用你的类的特定代码来重写这些方法。以下是本节所讨论的从?Object?类中继承的方法:

  • protected Object clone() throws CloneNotSupportedException?创建并返回此对象的副本。
  • public boolean equals(Object obj)?判断另一对象与此对象是否「相等」。
  • protected void finalize() throws Throwable?当垃圾回收机制确定该对象不再被调用时,垃圾回收器会调用此方法。
  • public final Class getClass()?返回此对象的运行时类。
  • public int hashCode()?返回此对象的散列码值。
  • public String toString()?返回此对象的字符串表示形式。

Object?类的?notify,notifyAll?和?wait?方法都在同步程序中独立运行线程的活动方面发挥了作用,这将在后面的课程中讨论,在此不做介绍。其中有五种方法:

  • public final void notify()
  • public final void notifyAll()
  • public final void wait()
  • public final void wait(long timeout)
  • public final void wait(long timeout, int nanos)

5. 为什么 String 对象是不可变的?

  1. 字符串池之所以可能,就是因为字符串在 Java 中是不可变的。由此 Java 运行时环境节省了大量堆空间,因为不同的 String 变量可以引用池中的同一 String 变量。如果 String 不是不可变的, 则字符串驻留(String interning)将是不可能的,因为一旦任一变量更改所引用的String对象的值,它也会反映在其他变量中。
  2. 如果字符串不是不可变的,那么它可能会对应用程序造成严重的安全威胁。例如,数据库用户名和密码都作为 String 传递以获取数据库连接,Socket 编程的主机和端口信息也是如此。由于字符串是不可变的,因此其值不能被更改。否则,任何黑客都可以篡改其引用的值,这会导致应用程序中的安全问题。
  3. 由于 String 是不可变的,因此它对与多线程处理来说是安全的,并且可以在不同的线程之间共享单个 String 实例。这避免了为线程安全使用同步;字符串是隐式线程安全的。
  4. 字符串被用在 Java 类加载器中,其不可变性为类加载器加载正确的类提供了安全性。否则的话,请考虑这样一个危险的情况,在你尝试加载?java.sql.Connection?类时,你引用的值却被更改为?myhacked.Connection,并且它能对数据库执行你不需要的操作。
  5. 由于 String 是不可变的,因此在它被创建时其散列码就被缓存,不需要再次计算。这使得它成为映射中键的理想对象,它的处理速度比其他HashMap?键类型快。这就是为什么 String 是?HashMap?中最常用的键类型。

为什么 Java 中的字符串不可变?点击这里了解更多。

6. final,finally,和 finalize 三者之间有什么不同?

这是我最喜欢的问题。

  • final?关键字用于在多个语境下定义只能分配一次的实体。
  • finally?代码块是用于执行重要代码 (如关闭连接、流等) 的代码块。无论是否处理异常,finally?代码块总会被执行。finally?代码块紧随?try?代码块或?catch?代码块。
  • 这是在删除或销毁对象之前垃圾回收器总会调用的方法,该方法使得垃圾回收机制能够执行清理活动。

7. 什么是菱形继承问题?

菱形继承问题反映了为什么在 Java 中我们不被允许实现多继承。如果有两个类共同继承一个有特定方法的超类,那么该方法会被两个子类重写。然后,如果你决定同时继承这两个子类,那么在你调用该重写方法时,编译器不能识别你要调用哪个子类的方法。

我们把这个问题称为?菱形继承问题?。上图对它作了说明,它也得名于此。

8. 如何使一个类不可变?

我认为这是一个相当困难的问题。您需要对类进行多次修改,以实现不可变性:

  1. 将类声明为?final,使其无法被继承。
  2. 所有域都用?private?修饰,不允许直接访问。
  3. 不提供变量的?setter?方法。
  4. 所有可变域都用?final?修饰, 使它的值只能分配一次。
  5. 通过构造函数执行深克隆初始化所有域。
  6. 对?getter?方法获取的对象执行克隆以返回副本,而不是返回实际的对象引用。

9. 什么是单例模式?

单例模式是指一个类仅允许创建其自身的一个实例,并提供对该实例的访问权限。它包含静态变量,可以容纳其自身的唯一和私有实例。它被应用于这种场景——用户希望类的实例被约束为一个对象。在需要单个对象来协调整个系统时,它会很有帮助。

10. 什么是依赖注入?

这是你必须知道的首要问题, 无论你是使用 Java EE 还是 Spring 框架。你可以看看我的文章,其中进一步地解释了这一点:?什么是依赖注入?

总结

在本文中,我们讨论了最常见的十个 Java 面试题——在我看来这是根据我的经验总结出的时下最重要的问题。如果你了解这些问题,我相信你能在面试中获得很大的优势。

希望我可以帮助到你!如果你有关于这个话题的类似经验,或者有一些成功的故事,不要犹豫,在下面的评论区中分享它们。

再见!

相关文章

]]>
//www.klh31.com/30956.html/feed 0
ImportNew一周资讯:开发者应该了解的 RabbitMQ 最佳实践 - ★广西快3龙虎★ //www.klh31.com/30822.html //www.klh31.com/30822.html#comments Mon, 17 Dec 2018 01:37:30 +0000 唐尤华 //www.klh31.com/?p=30822

ImportNew小编为您搜集有关Java业界、资源一周资讯(2018.12.17)。
(内容无特殊说明均为英文,这里仅做摘编,点击链接可直达原文。)

1. RabbitMQ 最佳实践(视频+文章):来自??pivotal

解读:这份视频列表里包含了以下内容:

 

2. J2CL—迟到总比不到好:来自?javacodegeeks

解读:J2CL 由 Google GWT 小组开发,可以把 Java 翻译成 Closure 风格的 JavaScript 代码。J2CL 通过转译器(transpiler)借助 Closure 编译器实现,基于?Bazel 进行构建。2015年齐 J2CL 开源就被提上了日程。2018年12月5日,Google 终于开源了 J2CL 的源代码 https://github.com/google/j2cl。尽管目前使用起来还有一些限制,但迟到总比不到好。

 

3. 使用 Java 10 Graal 和 C2 比较 Kotlin 性能:来自?javaadvent

解读:Java 10 引入了新的 Graal 编译器,对比传统的 C2 编译器优势如何?这篇文章用游戏程序对二者性能进行了测试。作者实现了曼德布洛特复数集合生成器(Mandelbrot Set?Generator)与背包解算器(Knapsack Solver),实现采用 Kotlin 语言,分别用 Graal 与 传统 C2 编译器编译。对比结果如下:

  • 曼德布洛特复数集合生成器测试:Graal 比 C2 快 18%。
  • 背包解算器(递归实现)测试:优化前?Graal?比 C2 慢?54%,改进 key 生成后 Graal 比 C2 快了一些。
C2 对经典的 Java 用法进行了大量优化,而 Graal 在小方法和轻量级对象上有优势,后者更符合 Kotlin 的使用习惯。

 

4. JDPR— Java数据?;ね萍?:来自 javaadvent

解读:个人用户信息(personally-identifiable information PII)?;ひ丫晌舜蠹夜刈⒌幕疤?,欧盟在2018年公布了GDPR(公民通用数据?;ぬ趵?/a>)。这篇文章介绍了在 Java 应用中?;じ鋈诵畔⑼萍龃胧?/p>

  1. 在应用中定位个人信息和敏感数据:比如在 POJO 中搜寻类似?getAddress()、getName() 这样的 API,在 JDBC 和 ORM 开发库中检查数据查询,借助类似 CONTRAST 这样的安全检查工具 ;
  2. 合理地进行加密:开发者可以很好地利用?Java 加密套件。JDK9 开始默认不限制加密能力(早先版本由于出口要求默认开启限制)。常见的加密方法包括哈希、对称加密与非对称加密。视频:如何应用 Java 加密;
  3. 为自定义代码、开发库与 JRE 打补丁??梢越柚?OWASP 依赖检查工具或?CONTRAST?社区版对项目进行已知漏洞检查。

 

5. Docker 与 JVM:来自 javaadvent

解读:“一次编写,到处运行”的问题。这句话对 Java class 本身没有问题,但数据库驱动、文件系统访问、网络访问、第三方开发库可能就没那么肯定了。对比传统虚拟机解决方案,在 Docker 上部署 Java 有几大优势,部署的文件小、可分层部署。例如,一个典型的 Dockerfile 可能类似这样,每个步骤都可以作为独立的层次(layer):

  1. 全新 Ubuntu 安装;
  2. 安装 Java;
  3. 安装依赖 A;
  4. 安装依赖 B;
  5. 拷贝 jar 文件。
当然,Docker 部署 Java 还是有一些坑。比如 JVM 无法“理解”容器的内存和 CPU 限制。文章里给出了 JVM Dockerfile 的通用解决方案。
本文作者在伦敦 CodeNode 上的视频讲解: Cloud Ready JVM with Kubernetes。

 

6. Serverless, Java 与 FN 项目,小试牛刀:来自 javaadvent

解读:除了传统的云服务厂商,越来越多的 Serverless 项目可以摆脱厂家的锁定,提供了更多的选择。这篇文章介绍了 FN 项目?//fnproject.io/,用 Java 方便地开发出一个 Serverless 功能。用 FN 开发一个 Serverless 功能主要有以下几步:

  1. 初始化建立项目:依赖?Docker 17.10.0-ce 或更高版本,下载 FN;
  2. 初始化 FN 功能:用 fn init 命令初始化项目结构,打开生成的?HelloFunction.java 处理请求,核心功能在 func.yaml 中提供了实现;
  3. 单元测试:实现?HelloFunctionTest.java,加入 @Run 添加依赖,添加测试代码;
  4. 部署与调用:验证功能,访问 //localhost:8080/t/myapp1/function1-trigger,返回 Hello, Java!;
  5. 扩展功能:使用 JSON 进行请求。

真的很迅速,可以自己动手试一下。

 

7. 如何用 Hibernate 把 PostgreSQL Enum 映射到 JPA 实体属性:来自?javaadvent

解读:hibernate-types 开源项目可以映射 JSON、数据、YearMonth、Month 或数据库里的数据列。这篇短文介绍了如何使用 JPA 和 Hibernate 映射?PostgreSQL Enum 类型:添加 Maven 依赖,定义模型,测试。

相关文章

]]>
//www.klh31.com/30822.html/feed 0
完美解决:Java微信语音amr格式转mp3格式,兼容Linux/Mac/Windows,支持Maven - ★广西快3龙虎★ //www.klh31.com/30922.html //www.klh31.com/30922.html#comments Sat, 15 Dec 2018 05:01:48 +0000 唐尤华 //www.klh31.com/?p=30922 广西快3开奖时间开奖:少费话,先上代码

引入 maven 依赖

 <dependency>
    <groupId>com.github.dadiyang</groupId>
    <artifactId>jave</artifactId>
    <version>1.0.0</version>
 </dependency>

调用 AudioUtils.amrToMp3 方法

三行代码搞定格式转换

public void amrToMp3()  {
    File source = new File("target/test-classes/material/testAudio.amr");
    File target = new File("testAudio.mp3");
    it.sauronsoftware.jave.AudioUtils.amrToMp3(source, target);
}

探索过程

最近接到基于微信公众号开发的需求,在处理微信消息的时候,发现语音类型的消息微信推送过来的是 amr 格式的文件,而在网页 HTML5的audio标签不支持amr格式,很是麻烦。

于是到处查资料,发现了 JAVE 这个项目,它封装了 ffmpeg 的命令,让开发者可以通过 Java 转换文件格式。

不幸的是,这个项目可谓年久失修,存在以下几个问题

JAVE 项目的问题

  1. 项目老旧没再维护。官网最近版本是2009年发布的,其依赖的ffmpeg早已过时,很多情况下用不了。
  2. 转码一直报异常 EncoderException: Stream mapping
  3. 没有发布maven仓库,而且 JAVE 本身也不是一个maven项目
  4. 不支持Mac OS

解决

本项目为解决上述问题,根据网上的资料进行整理和修改,我创建了一个 JAVE开源项目 并且发布到 maven中央仓库,让整个解决方案变得更加简单。

项目特点

  • 这是一个maven项目,而且已发布到中央仓库。
  • 项目依赖的 ffmpeg 可执行文件经过验证可以使用(单元测试中提供了一个简单的检验方法)
  • 解决了amr转mp3出现的 EncoderException: Stream mapping
  • 支持 Linux/Windows/Mac 平台

JAVE原理

  1. 初始化时判断当前运行环境,将bin目录中对应的 ffmpeg 可执行文件拷贝到临时目录中
  2. 根据文件类型及配置通过 Runtime.getRuntime().exec(cmd) 执行 ffmpeg 对应的转码命令

自定义 ffmpeg 路径

如果程序无法通过拷贝资源文件的方式获取到 ffmpeg 的可执行文件或者内置的 ffmpeg 不支持你所使用的操作系统

你可以通过环境变量或者在 java 中设置 System.setProperty("ffmpeg.home", "ffmpeg可执行文件所在的目录") 的方式指定你的系统中安装的可用的 ffmpeg 文件的目录,如 System.setProperty("ffmpeg.home", "/usr/local/bin/")

项目GitHub地址

参考

可能感兴趣的文章

]]>
//www.klh31.com/30922.html/feed 1
从零开始用好Maven:从HelloWorld到日常使用 - ★广西快3龙虎★ //www.klh31.com/30864.html //www.klh31.com/30864.html#comments Thu, 13 Dec 2018 01:53:05 +0000 唐尤华 //www.klh31.com/?p=30864 1. Maven简介

Apache Maven 是一个软件项目管理工具?;谙钅慷韵竽P停≒OM)的理念,通过一段核心描述信息来管理项目构建、报告和文档信息。

Maven 是一个意第绪语(犹太人使用的国际语)单词,意思是知识的累加器。它最开始是被用来简化 Jakarta Turbine 项目的构建过程。在 Jakarta Turbine 项目中有几个不同的项目,虽然它们的Ant构建文件差异很小,但是 jar 包都在 CVS 上。于是想要找到一个标准而又简单的项目构建方法,既可以清晰地定义出这个项目由什么构成并发布项目信息,又能在不同项目间共享Jar包。

现在,任何一个基于Java的项目都能使用Maven来构建和管理,使 Java 开发人员的日常工作变得更轻松,让Java项目更容易被理解。

2. Maven使用

2.1 安装

必备条件: 已安装JDK

注意事项: Maven 3.3 及更高版本要求 JDK1.7 或者更高版本

2.2 Windows

下载解压缩

bin\
boot\
conf\
lib\
README.txt
NOTICE
LICENSE

配置环境变量

  • 计算机 > 属性 > 高级系统设置 > 环境变量 > 系统变量
  • 新建 M2_HOME 变量,内容为 {解压路径}\apache-maven-{版本号}
  • 编辑 Path 变量,在内容结尾加上 ;%M2_HOME%\bin;

2.3 Linux

包管理器安装

$ sudo apt install maven

下载安装

  • 下载 apache-maven-{版本号}-bin.tar.gz
  • 配置环境变量 export PATH=/opt/apache-maven-{版本号}/bin:$PATH

2.4 验证

Windows 打开 Cmd,Linux 运行 Shell,看到下面信息表示安装成功。

$ mvn -version
Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-11T00:41:47+08:00)
Maven home: D:\software\java\apache-maven-3.3.9
Java version: 1.8.0_191, vendor: Oracle Corporation
Java home: c:\Program Files\java\jdk1.8.0_191\jre
Default locale: zh_CN, platform encoding: GBK
OS name: "windows 7", version: "6.1", arch: "amd64", family: "dos"

2.5 设置Maven

Maven通过 settings.xml 进行配置

完整的参数说明可查看 //maven.apache.org/ref/3.6.0/maven-settings/settings.html

2.5.1 自定义仓库位置(可选)

Maven 下载的 jar 包默认存储到 ${user.home}/.m2/repository

编辑 {安装路径}\config\settings.xml,在下面增加一行填入自定义位置:

  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->
<localRepository>{自定义位置}\repository</localRepository>

Linux 查看安装路径

$ ls -lsa /usr/share/maven
...
 0 lrwxrwxrwx   1 root root    10 12月 10  2015 conf -> /etc/maven

$ ls -lsa /etc/maven
 4 drwxr-xr-x   2 root root  4096 11月 27 11:45 logging
 4 -rw-r--r--   1 root root   222 11月 19  2015 m2.conf
12 -rw-r--r--   1 root root 10216 11月 19  2015 settings.xml
 4 -rw-r--r--   1 root root  3649 11月 19  2015 toolchains.xml

2.5.2 设置国内镜像(可选)

Maven 默认从中央仓库 central 下载

改为国内镜像速度更快

编辑 {安装路径}\config\settings.xml,在 <mirrors></mirrors> 标签里加入新的镜像:

<mirrors>
    <mirror>
      <id>alimaven</id>
      <mirrorOf>central</mirrorOf>
      <name>aliyun maven</name>
      <url>https://maven.aliyun.com/repository/central</url>
    </mirror>
</mirrors>

3. 使用

3.1 快速上手

3.1.1 新建示例项目

命令行不是必须的,但这个过程能有助于理解在 IDE 中的操作。

命令行新建项目

Windows 打开 Cmd,Linux 运行 Shell,执行下面指令。

mvn archetype:generate -DgroupId=org.tyh.mvn.quickstart -DartifactId=mvn-quickstart -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.3 -DinteractiveMode=false

执行成功可以看到下面字样:

[INFO] BUILD SUCCESS

POM.xml 包含了命令中的信息

<groupId>org.tyh.mvn.quickstart</groupId>
<artifactId>mvn-quickstart</artifactId>
<version>1.0-SNAPSHOT</version>
<name>mvn-quickstart</name>

目录结构

quickstart 项目的结构如下:

  • 项目源码:src/main/java
  • Web 项目源码:src/main/webapp
  • 测试源码:src/test/java
  • Maven 项目结构(Project Object Model POM):pom.xml

注意: 配置文件,如 log4j.properties 需要新建 src\main\resources 目录。这样编译时会打包到生成的 jar 中。

mvn-quickstart
│  pom.xml
│  
└─src
    ├─main
    │  └─java
    │      └─org
    │          └─tyh
    │              └─mvn
    │                  └─quickstart
    │                          App.java
    │                          
    └─test
        └─java
            └─org
                └─tyh
                    └─mvn
                        └─quickstart
                                AppTest.java

提示: 生成目录结构,Windows 在 Cmd 中输入 tree /f,Linux 安装 tree 程序后可直接输入 tree。

有关目录结构完整介绍可以查看

//maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html

3.1.2 构建项目

Windows 打开 Cmd,Linux 运行 Shell,执行下面指令。

mvn package

执行成功可以看到下面字样:

[INFO] BUILD SUCCESS

查看生成结果,在项目中新增了 target 目录,里面主要关注以下文件:

  • class 文件:target\classes\org\tyh\mvn\quickstart\App.class
  • test-classes 文件:target\test-classes\org\tyh\mvn\quickstart\AppTest.class
  • jar 文件:target\mvn-quickstart-1.0-SNAPSHOT.jar
mvn-quickstart
│  pom.xml
│ 
└─target
    │  mvn-quickstart-1.0-SNAPSHOT.jar
    │  
    ├─classes
    │  └─org
    │      └─tyh
    │          └─mvn
    │              └─quickstart
    │                      App.class
    │                      
    ├─generated-sources
    │  └─annotations
    ├─generated-test-sources
    │  └─test-annotations
    ├─maven-archiver
    │      pom.properties
    │      
    ├─maven-status
    │  └─maven-compiler-plugin
    │      ├─compile
    │      │  └─default-compile
    │      │          createdFiles.lst
    │      │          inputFiles.lst
    │      │          
    │      └─testCompile
    │          └─default-testCompile
    │                  createdFiles.lst
    │                  inputFiles.lst
    │                  
    ├─surefire-reports
    │      org.tyh.mvn.quickstart.AppTest.txt
    │      TEST-org.tyh.mvn.quickstart.AppTest.xml
    │      
    └─test-classes
        └─org
            └─tyh
                └─mvn
                    └─quickstart
                            AppTest.class

3.1.3 运行

Windows 打开 Cmd,Linux 运行 Shell,执行下面指令。

java -cp target/mvn-quickstart-1.0-SNAPSHOT.jar org.tyh.mvn.quickstart.App
Hello World!

执行测试:

mvn test

执行成功可以看到下面的结果:

[INFO] -------------------------------------------------------
[INFO]  T E S T S
[INFO] -------------------------------------------------------
[INFO] Running org.tyh.mvn.quickstart.AppTest
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.133 s - in org.tyh.mvn.quickstart.AppTest
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

3.2 新增依赖

3.2.1 搜索Maven

为项目添加一个依赖,比如 Apache Commons LangSlf4j 日志。

搜索

搜索时可采用高级搜索,g:{groupId} a:{artifactId}。例如 g:log4j a:log4j 就会列出 log4j 的最新版本。

注意: 类似 slf4j 这样依赖其他实现的包,需要查看官方文档,确认需要配合使用的 jar 包。否则会出 现编译通过,运行报错 的情况。

3.2.2 加入依赖项

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <!--Slf4j(slf4j-log4j12)-->
    <!--添加后,会同时引入 log4j 和 slf4j-api-->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.8.0-beta2</version>
    </dependency>

    <!--Apache Commons Lang (commons-lang3)-->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.8.1</version>
    </dependency>
</dependencies>

3.2.3 验证

修改 App 类,加入 Log 和 测试代码:

package org.tyh.mvn.quickstart;

import org.apache.commons.lang3.ArrayUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * ArrayUtils Demo
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        Logger logger = LoggerFactory.getLogger(App.class);

		float[] farr = {1.1f, 1.2f, 1.3f};
		logger.info(ArrayUtils.toString(farr));

		farr = ArrayUtils.removeElements(farr, 1.1f);
		logger.info(ArrayUtils.toString(farr));
    }
}

执行程序之前,要找到依赖的 jar 文件所在的目录。默认是在 {用户主目录}/.m2/ 目录 下,利用 dependency:copy 插件 可以拷贝到 target\dependency 目录:

mvn dependency:copy-dependencies

查看结果:

├─dependency
│      commons-lang3-3.8.1.jar
│      hamcrest-core-1.3.jar
│      junit-4.11.jar
│      log4j-1.2.17.jar
│      slf4j-api-1.8.0-beta2.jar
│      slf4j-log4j12-1.8.0-beta2.jar

在命令行运行时,用 -cp 加入依赖的 jar 所在目录:

java -cp .;dependency/*;mvn-quickstart-1.0-SNAPSHOT.jar org.tyh.mvn.quickstart.App

注意: 编译前需要加入 log4j.propertiessrc\main\resources 目录。下面是一个 Windows 下的 log4j.properties。

# Root logger option
log4j.rootLogger=INFO, file, stdout

# Direct log messages to a log file
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=C:\\temp\\logging.log
log4j.appender.file.MaxFileSize=10MB
log4j.appender.file.MaxBackupIndex=10
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

3.3 IDE中使用

3.3.1 Eclipse

新建项目

  1. 新建 Maven 项目
    • File > New > Project
    • 选择 Maven Project (目录报错及解决办法*)
    • (可?。┫钅坷嘈?maven-archetype-simple 或其他类型
    • 输入 Group Id, Artifact Id, Name,Finish
  2. 添加依赖
    • pom.xml 右键菜单 > Maven > Add Dependency
    • 在输入框中输入,比如 slf4j 会自动列出匹配结果,OK
    • 加入新的依赖保存文件,会在 Maven Dependencies 中列出 jar 及路径,并添加到项目的 classpath 中
  3. 编码
    • 编写 Java 代码,调试
  4. 构建
    • 项目 右键菜单 > Run As > Maven build
    • 第一次运行会提示输入 Maven build 的目标:Goal 里填写 package 进行构建 (支持的常用命令可以在这里找到 Maven in 5 Minutes:Maven Phases

导入项目

  • File > Import
  • 选择 Maven > Existing Maven Project
  • 选择项目 pom.xml 目录,Projects: 下面勾选 target
  • 点击完成

3.3.2 Idea

  1. 新建 Maven 项目
    • File > New > Project
    • 选择 Maven
    • (可?。┫钅坷嘈?maven-archetype-simple 或其他类型
    • 输入 Group Id, Artifact Id
    • 输入项目名称,Finish
  2. 添加依赖
    • pom.xml 手动添加依赖信息
    • 加入新的依赖保存文件,会在 External Libraries 中列出 jar 及路径,并添加到项目的 classpath 中
  3. 编码
    • 编写 Java 代码,调试
  4. 构建
    • pom.xml 右键菜单 > Build module’module name’
    • Maven build 会提示警告:Warning:java: 源值1.5已过时, 将在未来所有发行版中删除:可加入配置项解决

4. 常见问题与办法

4.1 如何设置编译支持的 JDK 版本?

全局指定

下面的脚本指定编译版本兼容 JDK 1.7

<project>
  ...
  <properties>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
  ...
</project>

指定插件

在不改变全局兼容性的情况下,可以在插件中指定。例如,下面的脚本指定了 maven-compiler-plugin 编译的版本兼容 JDK 1.7。

<project>
  ...
  <build>
  ...
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.3</version>
        <configuration>
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
    </plugins>
  ...
  </build>
  ...
</project>

4.2 如何指定自己的目录结构?

可以通过设置 <build> 节点下 <sourceDirectory>, <resources> 参数指定。

4.3 在 pom 文件中配置了依赖,编译时还会报错。

下载的 jar 文件可能有问题。

  • 检查 maven 仓库地址,在搜索条件中检查 groupId 和 artifactId 是否正确。
  • mvn clean 清理文件。
  • mvn package 重新编译。

4.4 [WARNING] File encoding has not been set, using platform encoding UTF-8, i.e. build is platform dependent!

POM 文件中没有指定编译时编码格式,可加入下面属性指定为 UTF-8。

<properties>
	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

类似的问题: [WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources, i.e. build is platform dependent!

4.5 Invalid project description. … overlaps the workspace …

Eclipse 新建 Maven 项目时,可能会报告此错误。解决办法两种:

  1. 选择 workspace 以外的目录作为项目目录;
  2. 新建 Java Project,然后转为 Maven 项目:右键菜单 Config -> Convert to Maven Project

4.6 Warning:java: 源值1.5已过时, 将在未来所有发行版中删除

Idea 在 Maven Build 时发出警告,在 pom.xml 中加入以下内容:

<build>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
        <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.0</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
    </plugins>
</build>

 

相关文章

]]>
//www.klh31.com/30864.html/feed 0
每周10道Java面试题:面向对象, 类加载器, JDBC, Spring 基础概念 - ★广西快3龙虎★ //www.klh31.com/30782.html //www.klh31.com/30782.html#comments Thu, 13 Dec 2018 01:26:30 +0000 唐尤华 //www.klh31.com/?p=30782

每周10道?Java?面试题由 ImportNew 整理编译自网络。
面试题答案讨论请移步:https://github.com/jobbole/java-interview/issues/1
Java面试题投递交流请移步:https://github.com/jobbole/java-interview/issues/2

1. 为什么说Java是一门平台无关语言?

平台无关实际的含义是“一次编写到处运行”。Java 能够做到是因为它的字节码(byte code)可以运行在任何操作系统上,与底层系统无关。

2. 为什么 Java 不是100%面向对象?

Java 不是100%面向对象,因为它包含8个原始数据类型,例如?boolean、byte、char、int、float、double、long、short。它们不是对象。

3. 什么是 singleton class,如何创建一个 singleton class?

Singleton class 在任何时间同一个 JVM 中只有一个实例??梢园压乖旌?private 修饰符创建 singleton。

4. 什么是多态?

多态简单地说“一个接口,多种实现”。多态的出现使得在不同的场合同一个接口能够提供不同功能,具体地说可以让变量、函数或者对象能够提供多种功能。下面是多态的两种类型:

  1. 编译时多态
  2. 运行时多态

编译时多态主要是对方法进行重载(overload),而运行时多态主要通过使用继承或者实现接口。

什么是运行时多态,也称动态方法分配?

在 Java 中,运行时多态或动态方法分配是一种在运行过程中的方法重载。在这个过程中,通过调用父类的变量引用被重载的方法。下面是一个例子:

class Car {
	void run()
	{
		System.out.println(“car is running”); 
	}
}
class Audi extends Car {
	void run()
	{
		System.out.prinltn(“Audi is running safely with 100km”);
	}
	public static void main(String args[])
	{
		Car b= new Audi();    //向上转型
		b.run();
	}
}

5. Java类加载器包括几种?它们之间的关系是怎么样的?

Java 类加载器有:

  • 引导类加载器(bootstrap class loader):只加载 JVM 自身需要的类,包名为 java、javax、sun 等开头。
  • 扩展类加载器(extensions class loader):加载 JAVA_HOME/lib/ext 目录下或者由系统变量 -Djava.ext.dir 指定位路径中的类库。
  • 应用程序类加载器(application class loader):加载系统类路径 java -classpath 或 -Djava.class.path 下的类库。
  • 自定义类加载器(java.lang.classloder):继承 java.lang.ClassLoader 的自定义类加载器。

注意:-Djava.ext.dirs 会覆盖 Java 本身的 ext 设置,造成 JDK 内建功能无法使用??梢韵裣旅嬲庋付ú问?/p>

-Djava.ext.dirs=./plugin:$JAVA_HOME/jre/lib/ext。

它们的关系如下:

  • 启动类加载器,C++实现,没有父类。
  • 扩展类加载器(ExtClassLoader),Java 实现,父类加载器为 null。
  • 应用程序类加载器(AppClassLoader),Java 实现,父类加载器为 ExtClassLoader 。
  • 自定义类加载器,父类加载器为AppClassLoader。

7. 什么是JDBC驱动?

JDBC Driver 是一种实现 Java 应用与数据库交互的软件。JDBC 驱动有下面4种:

  1. JDBC-ODBC bridge 驱动
  2. Native-API 驱动(部分是 Java 驱动)
  3. 网络协议驱动(全部是 Java 驱动)
  4. Thin driver(全部是 Java 驱动)

8. 使用 Java 连接数据库有哪几步?

  • 注册驱动类
  • 新建数据库连接
  • 新建语句(statement)
  • 查询
  • 关闭连接

9. 列举Spring配置中常用的重要注解。

下面是一些重要的注解:

  • @Required
  • @Autowired
  • @Qualifier
  • @Resource
  • @PostConstruct
  • @PreDestroy

10. Spring中的Bean是什么?列举Spring Bean的不同作用域。

Bean 是 Spring 应用的骨架。它们由 Spring IoC 容器管理?;痪浠八?,Bean 是一个由?Spring IoC 容器初始化、装配和管理的对象。

下面是 Spring Bean 的5种作用域:

  • Singleton:每个容器只创建一个实例,也是 Spring Bean 的默认配置。由于非线程安全,因此确保使用时不要在 Bean 中共享实例变量,一面出现数据不一致。
  • Prototype:每次请求时创建一个新实例。
  • Request:与 prototype 相同,区别在于只针对 Web 应用。每次 HTTP 请求时创建一个新实例。
  • Session:每次收到 HTTP 会话请求时由容器创建一个新实例。
  • 全局 Session:为每个门户应用(Portlet App)创建一个全局 Session Bean。

相关文章

]]>
//www.klh31.com/30782.html/feed 1
Spring源码探究:容器 - ★广西快3龙虎★ //www.klh31.com/30835.html //www.klh31.com/30835.html#comments Thu, 13 Dec 2018 01:19:51 +0000 唐尤华 //www.klh31.com/?p=30835

结合源码分析 Spring 容器与 SpringMVC 容器之间的关系


问题

问题描述:项目中发现,自定义切面注解在 Controller 层正常工作,在 Service 层却无法正常工作。为了便于分析,去掉代码中的业务逻辑,只留下场景。

自定义注解,打印时间

/**
 * Description: 自定义打印时间的注解
 * Created by jiangwang3 on 2018/5/9.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface PrintTime {
}

注解解析器

/**
 *Description:打印时间注解的解析器
 * @author jiangwang
 * @date 11:28 2018/5/14
 */
@Aspect
public class PrintTimeProcessor {
    private Logger LOGGER = LoggerFactory.getLogger(getClass());
    @Pointcut("@annotation(com.foo.service.annotation.PrintTime)")
    public void printTimePoint() {
    }
    @Around("printTimePoint()")
    public Object process(ProceedingJoinPoint jp) throws Throwable{
        System.out.println();
        LOGGER.error("开始运行程序。。。Start==>");
        Object proceed = jp.proceed();
        LOGGER.error("结束啦,运行结束==>");
        System.out.println();
        return proceed;
    }
}

Controller层

/**
 * @author jiangwang
 * @date  2018/5/14
 */
@RestController
@RequestMapping(value = "/user")
public class UserController {
    private Logger logger = LoggerFactory.getLogger(getClass());
    @Resource
    private UserService userService;
    @RequestMapping(value = "/serviceAspect", method={RequestMethod.GET})
    public  String serviceAspect(){
        return userService.serviceAspect();
    }
    @RequestMapping(value = "/controllerAspect", method={RequestMethod.GET})
    @PrintTime
    public  String name(){
        logger.info("Controller层----测试切面");
        return "controllerAspect";
    }
}

Service层

/**
 * @author jiangwang
 * @date 11:34 2018/5/14
 */
@Service
public class UserService {
    private Logger logger = LoggerFactory.getLogger(getClass())
    @PrintTime
    public String serviceAspect(){
        logger.info("Service层---测试切面");
        return "serviceAspect";
    }
}

spring.xml 配置文件,主要部分

<context:annotation-config />
<!-- 动态代理开启 -->
<aop:aspectj-autoproxy proxy-target-class="true" />
<context:component-scan base-package="com.foo" >
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- 公共配置引入 -->
<import resource="classpath:spring/spring-config-dao.xml" />

springmvc.xml 配置文件,主要部分

<mvc:annotation-driven />
<mvc:default-servlet-handler />
<!-- 动态代理开启 -->
<aop:aspectj-autoproxy proxy-target-class="true" />
<!-- mvc controller -->
<context:component-scan base-package="com.foo.web.controller" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service" />
</context:component-scan>
<bean class="com.foo.service.processor.PrintTimeProcessor"/>

以上为主要代码。项目运行之后,发现在 Service 层的注解切面未生效,而在 Controller 层正常。而当我将 springmvc.xml 中的

<bean class="com.foo.service.processor.PrintTimeProcessor"/>

迁移至 spring.xml 中,发现 Service 层与 Controller 层的注解切面均可正常运行。WHY???


从源码的角度探究该问题

由于源码中的方法较长,所以只贴出重点且与主题相关的代码。建议结合本地源码一起看。

为了说清楚这个问题,咱们先看一下Spring容器是如何实现 Bean 自动注入(简化版)

Web 项目的入口是 web.xml,所以咱们从它开始。

web.xml 配置文件,主要部分

<!-- Spring Config -->
<listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:spring/spring-config.xml</param-value>
</context-param>

<!-- SpringMvc Config -->
<servlet>
  <servlet-name>springMvc</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring/spring-mvc.xml</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
  <servlet-name>springMvc</servlet-name>
  <url-pattern>/*</url-pattern>
</servlet-mapping>

Spring 容器 Bean 加载流程

从 Spring 配置部分可以看出,ContextLoaderListener 监听器是 Spring 容器的入口,进入该文件:

public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
    public ContextLoaderListener() {
    }
    public ContextLoaderListener(WebApplicationContext context) {
        super(context);
    }
    @Override
    public void contextInitialized(ServletContextEvent event) {
        initWebApplicationContext(event.getServletContext());
    }
    @Override
    public void contextDestroyed(ServletContextEvent event) {
        closeWebApplicationContext(event.getServletContext());
        ContextCleanupListener.cleanupAttributes(event.getServletContext());
    }
}

ContextLoaderListener 监听器一共有四个方法,可以很容易地判断出来,进入该监听器后,会进入初始化方法:contextInitialized。继而进入?initWebApplicationContext?方法,方法注释中?“Initialize Spring’s web application context for the given servlet context”,明确表明了该方法的目的是初始化 Spring Web 应用。这段代码中有两句话比较关键:

this.context = createWebApplicationContext(servletContext);

创建 Web 应用容器,即创建了 Spring 容器;

configureAndRefreshWebApplicationContext(cwac, servletContext);

配置并刷新Spring容器。后续发生的所有事,都是从它开始的。进入,里面的重点代码是:

wac.refresh();

refresh()?方法是spring容器注入bean的核心方法,每一行代码都很重要。代码结构也非常优美,每一行代码背后都完成了一件事,代码结构比较容易理解。由于内容较多,只讲里面跟主题相关的两句话:

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

获取 Bean 工厂,把你配置文件中的内容,放在 Bean 工厂中,留着后面创建 Bean 时用。

finishBeanFactoryInitialization(beanFactory);

开始创建 Bean,即实现 Spring 中的自动注入功能。进入该方法后,末尾有这么一句话:

beanFactory.preInstantiateSingletons();

继续跟进,贴出该方法中的重点代码:

getBean(beanName);

我们在 preInstantiateSingletons() 方法中,会发现有多个地方出现了 getBean() 方法,究竟咱们贴出来的是哪一句?无关紧要。跟进去之后,

@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

这里调用了 doGetBean() 方法,Spring 中只要以?do?命名的方法,都是真正干活的。重点代码分段贴出分析:

// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
    if (logger.isDebugEnabled()) {
        if (isSingletonCurrentlyInCreation(beanName)) {
            logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                    "' that is not fully initialized yet - a consequence of a circular reference");
        }
        else {
            logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
        }
    }
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}

直接获取单例 Bean,若没有取到,继续往下走:

// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    // Not found -> check parent.
    String nameToLookup = originalBeanName(name);
    if (args != null) {
        // Delegation to parent with explicit args.
        return (T) parentBeanFactory.getBean(nameToLookup, args);
    }
    else {
        // No args -> delegate to standard getBean method.
        return parentBeanFactory.getBean(nameToLookup, requiredType);
    }
}

这一段代码单独看,不知所云,里面提到了一个词:Parent。暂且跳过,后续会回来分析这一段。继续:

// Create bean instance.
if (mbd.isSingleton()) {
       sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
            @Override
             public Object getObject() throws BeansException {
                 try {
                     return createBean(beanName, mbd, args);
                  }
                  catch (BeansException ex) {
                      // Explicitly remove instance from singleton cache: It might have been put there
                      // eagerly by the creation process, to allow for circular reference resolution.
                      // Also remove any beans that received a temporary reference to the bean.
                      destroySingleton(beanName);
                      throw ex;
                 }
                }
         });
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

这段代码中有 createBean,咱们的目的是分析 Bean 的创建过程,此处出现了?create,毫不犹豫地跟进,进入实现类中的方法,有这么一句:

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

刚才咱们提了,Spring 中有?do?命名的方法,是真正干活的。跟进:

instanceWrapper = createBeanInstance(beanName, mbd, args);

这句话是初始化 Bean,即创建了?Bean,等价于调用了一个类的空构造方法。此时,已经成功地创建了对象,下文需要做的是,给该对象注入需要的属性;

populateBean(beanName, mbd, instanceWrapper);

填充?Bean 属性,就是刚才咱们提的,初始化一个对象后,只是一个空对象,需要给它填充属性。跟进,看 Spring 是如何为对象注入属性的,或者说,看一下 Spring 是如何实现 Bean 属性的自动注入:

pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);

继续进入 AutowiredAnnotationBeanPostProcessor 的 postProcessPropertyValues 方法:

metadata.inject(bean, beanName, pvs);

这句话中,出现了?inject,这个词的意思是“注入”。咱们可以断定,Spring 的自动注入,八成跟它有关了。进入该方法:

<code>element.inject(target, beanName, pvs); </code>

与上一句一样,只是做了一些参数处理,并没有开始注入。继续跟进看:

Field field = (Field) this.member;
ReflectionUtils.makeAccessible(field);
field.set(target, getResourceToInject(target, requestingBeanName));

看到这里,大概明白了 Spring 是如何自动注入了。Java 反射相关的代码,通过反射的方式给 field 赋值。这里的?field?是 Bean 中的某一个属性,例如咱们开始时的 UserController 类中的?userService。getResourceToInject,获取需要赋予的值了,其实这里会重新进入 getBean 方法,获取 Bean 值(例如 UserController 对象中需要注入 userService。),然后赋予 field。至此,Spring容器已经初始化完成,Spring Bean注入的大概流程,咱们也已经熟悉了?;氐娇汲跏蓟?Spring 容器的地方,ContextLoader 类 initWebApplicationContext 方法,

servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

初始化 Spring 容器之后,将其放入了 servletContext 中。

咱们的问题是,“在项目中,自定义切面注解在 Controller 层正常工作,却在 Service 层无法正常工作?”看完这个,其实并没有解答该问题,咱们下面继续看 SpringMVC Bean的加载流程,看完 SpringMVC 后,答案会自动浮出水面。


SpringMVC 容器 Bean 加载流程

同样,从 web.xml 中的?SpringMVC 配置出发,里面有 DispatcherServlet,这是 SpringMVC 的入口,跟进之后发现方法较多,无法知道会执行哪个方法。但是咱们要记住,DispatcherServlet?本质上是一个 Servlet,通过它的继承关系图也可以证明:

DispatcherServlet继承关系图

看一下 Servlet 的接口:

public interface Servlet {
    public void init(ServletConfig config) throws ServletException;
    public ServletConfig getServletConfig();
    public void service(ServletRequest req, ServletResponse res)
            throws ServletException, IOException;
    public String getServletInfo();
    public void destroy();
}

从 Servlet 接口方法中可以看出,Servlet 的入口是?init?方法,层层跟进(一定要根据 DispatcherServlet 继承图跟进),进入到了 FrameworkServlet 的?initServletBean()?方法,进入方法,贴出重点代码:

this.webApplicationContext = initWebApplicationContext();

字面理解,初始化?SpringMVC Web容器,进入探究:

WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(getServletContext());

前面咱们提到,Spring 容器初始化完成之后,放入了?servletContext?中。这里又从 servletContext 获取到了?Spring 容器;

wac = createWebApplicationContext(rootContext);

字面理解创建 Web 应用容器,且参数是 Spring 容器。跟进方法:

ConfigurableWebApplicationContext wac = (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

创建web应用容器,即咱们所理解的 SpringMVC?容器在此创建了;

wac.setParent(parent);

这里是重点,SpringMVC?容器将 Spring 容器设置成了自己的父容器。

configureAndRefreshWebApplicationContext(wac);

这个方法刚才在分析 Spring Bean 加载流程时,分析过了。其中有一段,前面说,“暂且跳过,后续会回来分析这一段”。现在开始分析:

在 AbstractBeanFactory 类 doGetBean 方法,有这么一段:

// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    // Not found -> check parent.
    String nameToLookup = originalBeanName(name);
    if (args != null) {
            // Delegation to parent with explicit args.
        return (T) parentBeanFactory.getBean(nameToLookup, args);
    }
    else {
        // No args -> delegate to standard getBean method.
        return parentBeanFactory.getBean(nameToLookup, requiredType);
    }
}

这里其实是在获取父容器中的 Bean,若获取到,直接拿到 Bean,这个方法就结束了。结论:子容器可以使用父容器里的 Bean,反之则不行。


现在来解答咱们的问题

<bean class="com.foo.service.processor.PrintTimeProcessor"/>

当上门这句话放在 springmvc.xml 中时,名为?“printTimeProcessor”?的 Bean 会存在于 SpringMVC 容器,那么 Spring 容器是无法获取它的。而 Service 层恰巧是存在于 Spring 容器中,所以?“printTimeProcessor”?切面对 Service 层不起作用。而 Controller 层本身存在于 SpringMVC 容器,所以 Controller 层可以正常工作。而当它放在 spring.xml 中时,”printTimeProcessor” 是存在于 Spring 容器中,SpringMVC 容器是 Spring 容器的子容器,子容器可以获取到父容器的 Bean,所以 Controller 层与 Service 层都能获取到该 Bean,所有都能正常使用它。

相关文章

]]>
//www.klh31.com/30835.html/feed 1
  • 2017年秋季学期学员第十六支部风采 2019-04-18
  • 中国核电发展处机遇期 未来20年发电量占比或翻两番 2019-04-14
  • 女性之声——全国妇联 2019-04-13
  • 我不是怕死,而是怕那种沉闷又无聊的生活 2019-04-12
  • 王国平应邀为杭州市农村历史建筑保护研讨会作专题讲座 2019-04-12
  • 零下12℃ 北京密云消防员练冰上救援功夫 2019-03-29
  • 女子5万卖掉1岁多女儿 当天就花6000元买化妆品等 2019-03-29
  • Conférence de presse du Premier ministre chinois 2019-03-23
  • 我发现从五+年代农业用化肥农药,在六+年代几百年长的柿树几乎死光。没人研究! 2019-03-23
  • 西部消化疾病内镜诊疗新力量杨琦 2019-03-21
  • 中纪委:有干部不信马列信鬼神 触犯纪律信小圈子 2019-03-21
  • 进度紧追中国航母!英第二艘女王级完工 2019-03-19
  • 凤凰公映礼之《父子雄兵》 2019-03-19
  • 社会主义是一个真正的民主国家,这里的人民当家做主, 2019-03-12
  • 高校“双一流”建设:从美国高校看“四个回归” 2019-03-12