Mybatis与hibernate-自己的理解 

Hibernate做了写优化，比如一二三级缓存，把数据存放在缓存里面，这里是通过OID去区分是否为同一个对象，存放在内存。

今天同事问了我下：Hibernate中get/load区别以及为什么不能final修饰？ 

因为load得到的是代理类型对象，final是不能被继承的 

get直接得到了一个持久化类型对象，它就是立即查询操作 

load它得到的是持久化类开的代理类型对象（子类对象）。它采用了一种延迟策略来查询数据。 

4.get方法在查询时，如果不存在返回null 

load方法在查询时，如果 不存在，会产生异常

自己的话来说hibernate的一二级缓存的理解，一级缓存就是session，比如get,load，query之类的操作就会把数据存在session里面，后面调用close就会关闭，而二级缓存就是sessionfactory

二哥，你能给我说说为什么 String 是 immutable 类（不可变对象）吗？我想研究它，想知道为什么它就不可变了，这种强烈的愿望就像想研究浩瀚的星空一样。但无奈自身功力有限，始终觉得雾里看花终隔一层。二哥你的文章总是充满趣味性，我想一定能够说明白，我也一定能够看明白，能在接下来写一写吗？

收到读者小 R 的私信后，我就总感觉自己有一种义不容辞的责任，非要把 immutable 类说明白，否则我就怎么地——你说了算！

01、什么是不可变类
一个类的对象在通过构造方法创建后如果状态不会再被改变，那么它就是一个不可变（immutable）类。它的所有成员变量的赋值仅在构造方法中完成，不会提供任何 setter 方法供外部类去修改。
还记得《神雕侠侣》中小龙女的古墓吗？随着那一声巨响，仅有的通道就被无情地关闭了。别较真那个密道，我这么说只是为了打开你的想象力，让你对不可变类有一个更直观的印象。
自从有了多线程，生产力就被无限地放大了，所有的程序员都爱它，因为强大的硬件能力被充分地利用了。但与此同时，所有的程序员都对它心生忌惮，因为一不小心，多线程就会把对象的状态变得混乱不堪。
为了保护状态的原子性、可见性、有序性，我们程序员可以说是竭尽所能。其中，synchronized（同步）关键字是最简单最入门的一种解决方案。
假如说类是不可变的，那么对象的状态就也是不可变的。这样的话，每次修改对象的状态，就会产生一个新的对象供不同的线程使用，我们程序员就不必再担心并发问题了。
02、常见的不可变类
提到不可变类，几乎所有的程序员第一个想到的，就是 String 类。那为什么 String 类要被设计成不可变的呢？
1）常量池的需要
字符串常量池是 Java 堆内存中一个特殊的存储区域，当创建一个 String 对象时，假如此字符串在常量池中不存在，那么就创建一个；假如已经存，就不会再创建了，而是直接引用已经存在的对象。这样做能够减少 JVM 的内存开销，提高效率。
2）hashCode 的需要
因为字符串是不可变的，所以在它创建的时候，其 hashCode 就被缓存了，因此非常适合作为哈希值（比如说作为 HashMap 的键），多次调用只返回同一个值，来提高效率。
3）线程安全
就像之前说的那样，如果对象的状态是可变的，那么在多线程环境下，就很容易造成不可预期的结果。而 String 是不可变的，就可以在多个线程之间共享，不需要同步处理。
因此，当我们调用 String 类的任何方法（比如说 trim()、substring()、toLowerCase()）时，总会返回一个新的对象，而不影响之前的值。
String cmower = "沉默王二，一枚有趣的程序员";
cmower.substring(0,4);
System.out.println(cmower);// 沉默王二，一枚有趣的程序员

虽然调用 substring() 方法对 cmower 进行了截取，但 cmower 的值没有改变。
除了 String 类，包装器类 Integer、Long 等也是不可变类。
03、自定义不可变类
看懂一个不可变类也许容易，但要创建一个自定义的不可变类恐怕就有点难了。但知难而进是我们作为一名优秀的程序员不可或缺的品质，正因为不容易，我们才能真正地掌握它。
接下来，就请和我一起，来自定义一个不可变类吧。一个不可变诶，必须要满足以下 4 个条件：
1）确保类是 final 的，不允许被其他类继承。
2）确保所有的成员变量（字段）是 final 的，这样的话，它们就只能在构造方法中初始化值，并且不会在随后被修改。
3）不要提供任何 setter 方法。
4）如果要修改类的状态，必须返回一个新的对象。
按照以上条件，我们来自定义一个简单的不可变类 Writer。
public final class Writer {
    private final String name;
    private final int age;

    public Writer(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }
}

Writer 类是 final 的，name 和 age 也是 final 的，没有 setter 方法。
OK，据说这个作者分享了很多博客，广受读者的喜爱，因此某某出版社找他写了一本书（Book）。Book 类是这样定义的：
public class Book {
    private String name;
    private int price;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

2 个字段，分别是 name 和 price，以及 getter 和 setter，重写后的 toString() 方法。然后，在 Writer 类中追加一个可变对象字段 book。
public final class Writer {
    private final String name;
    private final int age;
    private final Book book;

    public Writer(String name, int age, Book book) {
        this.name = name;
        this.age = age;
        this.book = book;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public Book getBook() {
        return book;
    }
}

并在构造方法中追加了 Book 参数，以及 Book 的 getter 方法。
完成以上工作后，我们来新建一个测试类，看看 Writer 类的状态是否真的不可变。
public class WriterDemo {
    public static void main(String[] args) {
        Book book = new Book();
        book.setName("Web全栈开发进阶之路");
        book.setPrice(79);

        Writer writer = new Writer("沉默王二",18, book);
        System.out.println("定价：" + writer.getBook());
        writer.getBook().setPrice(59);
        System.out.println("促销价：" + writer.getBook());
    }
}

程序输出的结果如下所示：
定价：Book{name='Web全栈开发进阶之路', price=79}
促销价：Book{name='Web全栈开发进阶之路', price=59}

糟糕，Writer 类的不可变性被破坏了，价格发生了变化。为了解决这个问题，我们需要为不可变类的定义规则追加一条内容：
如果一个不可变类中包含了可变类的对象，那么就需要确保返回的是可变对象的副本。也就是说，Writer 类中的 getBook() 方法应该修改为：
public Book getBook() {
    Book clone = new Book();
    clone.setPrice(this.book.getPrice());
    clone.setName(this.book.getName());
    return clone;
}

这样的话，构造方法初始化后的 Book 对象就不会再被修改了。此时，运行 WriterDemo，就会发现价格不再发生变化了。
定价：Book{name='Web全栈开发进阶之路', price=79}
促销价：Book{name='Web全栈开发进阶之路', price=79}

04、总结
不可变类有很多优点，就像之前提到的 String 类那样，尤其是在多线程环境下，它非常的安全。尽管每次修改都会创建一个新的对象，增加了内存的消耗，但这个缺点相比它带来的优点，显然是微不足道的——无非就是捡了西瓜，丢了芝麻。

最后，一定会有不少读者想要问我怎么学习 Java 的，那我干脆就把我看过的优质书籍贡献出来：
1）入门版：《Head First Java》、《Java 核心技术卷》
2）进阶版：《Java编程思想》、《Effective Java》、《Java网络编程》、《代码整洁之道》
3）大牛版：《Java并发编程》、《深入理解Java虚拟机》、《Java性能权威指南》、《重构》、《算法》
就先介绍这么多，希望对那些不知道看什么书的同学有所帮助。

对了，我介绍的这些书籍，已经顺便帮你整理好了，你可以在我的原创微信公众号『沉默王二』回复『书籍』获取哦

有收获？希望老铁们来个三连击，给更多的同学看到这篇文章
1、老铁们，关注我的原创微信公众号「沉默王二」，专注于有趣有益的程序人生，保证你看完有所收获，不信你打我。
2、给二哥点个赞呗，可以让更多的人看到这篇文章，顺便激励下我，嘻嘻。

作者info

作者：沉默王二，CSDN 2019年度博客之星，《Web全栈开发进阶之路》作者

原创公众号：『沉默王二』，已写了 250 多篇文章，专注于有趣的 Java 技术和有益的程序人生，期待你的关注。

转载说明：务必注明来源（注明：来源于公众号：沉默王二， 作者：沉默王二）

按照惯例，先做一个简单的介绍，现在开始学习 Thinging in Java 4 ，一边看，一边记录，我都不想给自己设定时间安排了，毕竟很少实现过。所以就这样吧！不定期的更新，我都会放到专栏中的。

所以我可能会有很多表述和书中是一样的，外加一些自己的理解吧。

我们常说的一句话是“一切皆对象”这话也就说说吧，理解吗？其实并不理解。没关系，我们可以假装理解了。那我就来结合书中的观点说一下面向对象的概念吧！若是你没有一点面向对象的概念，那你不用看了，去玩吧！

首先问一下自己编程是什么呢 ？数据结构 + 算法 = 编程 ，算法说的简单一点就是事情的解决步骤。编程语言（C,C++,Java,Python…）只是一种工具，我们学习Java无非就是为了编程，所以我们对于Java中的数据结构的理解就显得尤其重要了。数据结构又是什么呢？就是在研究数据以及数据之间的关系和操作。在Java中数据就体现为对象。所以我们要学习的也就是对象以及对象之间的关系和对象相关的操作。

前面说到Java中一切皆是对象，那我们怎么去操作这些对象呢？这些对象又放在哪里的呢？在Java中我们通过引用的方式来操作对象，打个比方来说，我们的引用就相当于遥控器，而电视机就是对象，我们对电视机（对象）的操作（加减声音，换台）都是通过操作遥控器（引用）实现的。举个具体的例子：


  
String s = ‘learn Java’；


这里的s就是一个引用，引用的数据也就是learn Java，这里涉及一个Java中的知识点，字符串这个对象可以用引号直接为其赋值。我们需要用到什么对象都由我们自己创建，那么一般的对象我们是怎么创建的呢？使用关键字 new 即可创建一个对象。 

例如：String s = new String("learn java"); 这就是创建一个名为learn java字符串的对象并且用s引用它。那我辛辛苦苦创建的对象都放在哪里了呢？不得不多，这里就涉及计算机硬件方面的知识了，不懂就去补吧。我们创建的对象的引用，还有一些基本数据类型的变量会存放在栈中，而创建的对象会放在堆内存中（目前是只可意会不可言传的阶段）有必要说一下，有些对象是可以脱离程序存在的，在程序没有运行的时候也可以存在，比方说流对象和持久化对象。在流对象中，对象转化成字节流，通常被发送给另一台机器。在”持久化对象中“对象被存放于磁盘上因此，即使程序结束，它也可以保存自己的状态。

总会存在特例，Java中的数据类型可以分为基本数据类型和引用数据类型，对于基本数据类型一种有8种，分别是 byte short int long float double char（2个字节 16 bit）boolean ，为什么会出现这些基本数据类型，原来是因为它们使用太频繁，我们说过，对象是存放在堆中的，而对于这种小型的频繁使用的数据放在堆中加大了对象创建和使用的时间，所以就单独列出来，用于提高Java的效率。

对于基本数据类型在JDK5中提供了自动包装功能，就是说本来是基本数据类型的自动转化为包装类。int i = 2; <==> Integer j = new Integer(i); 每一种基本数据类型所占用的存储空间都是固定的。这也是Java可移植性性的保证！

另外Java中提供了两个高精度的类BigInteger 和 BigDecimal ,它们就是用于支持任意精度的整数和任意精度的定点数。

所有的对象都是由我们自己创建，那我们创建的对象都是什么类型的呢？除了一些JDK内置的类型，我们可以使用关键字class 来自定义对象的类型。也就是我们常说的类。在类中我们可以定义对象的属性和方法，每创建一个对象都拥有自己的副本。属性也叫成员变量，在类中的成员变量都有自己的初始化值，但是局部变量若是不赋初值的话就会报错，类的另一个组成就是方法了，也叫函数，可以理解为对象的功能，我们定义方法的目的就在于和对象进行对话或“交互”。我们调用方法的行为通常被称为发送消息给对象。 

例如：a.f(); 可以理解为消息是 f() ,a 是对象。

面向对象的程序设计通常简单地归纳为“向对象发送消息”。 

在 ES5 中，有的人可能对原型，原型对象，及其原型链不是很清楚，经过我的总结 今天就来说说对这些的深入认识，如果有不妥之处 还请多多指出
首先，再说原型与原型对象之前，当然有必要清楚构造函数，实例，原型与原型对象之间的关系。其实他们的关系也很简单。

构造函数，实例，原型与原型对象之间的关系：
构造函数有它自己的属性及其方法，其中包括自己定义的属性和方法外，还有两个特殊属性（prototype、constructor）；而每个他的实例都会拥有它的所有属性和方法（包括prototype、constructor）constructor则是指向每个实例的构造函数，而prototype 原型 则是一个地址指向原型对象，这个原型对象创建了实例后，只会取得constructor属性，其他的都是从Object继承而来；在Firefox 、 chrome在对象上都支持一个属性"proto";这个原型对象的属性和方法是所有该类实例共享的任何该类实例够可以访问该原型对象的属性和方法（后面会介绍访问原型对象属性和方法的三个方式）

　　

　　

　　如上图，p1 ,p2的的实例都有Person的属性和方法，并且prototype都指向原型对象，p1\p2共享prototype原型对象的属性和方法，各自的constructor都指向Peson，这便是构造函数、实例、原型（对象）三者的关系。
现在我来说一说访问原型对象属性和方法的三个方式：
1.通过Person.prototype 属性
console.log(Person.prototype.name)；//输出----->person
2.通过 属性屏蔽 delete （屏蔽构造函数属性或者方法）
p1.sayName();     　　//输出----->构造函数对象
delete p1.name;
console.log(p1.name); //输出----->原型属性
delete p1.sayName;
p1.sayName(); //输出 —>原型对象方法
3.通过Object.getPrototypeOf(p1)
console.log(Object.getPrototypeOf(p1).name);//输出----->原型属性
上面我们需要注意就是当实例调用属性或者方法时，有一个”属性搜索机制“，所谓”属性搜索机制“就是当实例访问属性或者方法时首先会现在自身的实例中搜索，看是否有对应属性，有，则返回；如果没有那么它会通过prototype 到原型对象中寻找对应的属性和方法；
原型链：
其基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法。我们知道，每个构造函数都有一个原型对象，每个原型对象都有一个指向构造函数的指针，而实例又包涵一个指向原型对象的内部指针。
如果我们让原型对象（A.prototype） = 另一个类型的实例（new B()），那么，该原型对象（A.prototype）就有一个指向另一个原型对象（B.prototype）的指针，相应的，另一个原型对象（B.prototype）也包含指向另一个构造函数（B）的指针。          ------------->如果另一个的原型（B.prototype）又是另一个类型（C）的实例，上诉关系依然成立，就构成了实例与原型的链条，这就是原型链。
实现原型链的基本方法：
function Person () {
    this.name = "person";
}
 
Person.prototype.getPersonName = function () {
    return this.name;
};
 
function Student () {
    this.studentname = "student";
}
 
// 继承了Person
Student.prototype = new Person();
Student.prototype.getStudentName = function () {
    return this.name;
};
 
var stu = new Student();
console.log(stu.getPersonName());           //person


如上就是通过将　Student（）的prototype = new Person（） 即子类的原型对象等于父类的实例，从而Student.prototype有了Person的所有属性和方法，实现了继承。通过实现原型链，再结合 “属性搜索机制“，则
stu.getPersonName()

会经过三个阶段：1.搜索实例 2.搜索Student.prototype 3.搜索Person.prototype;如果再没就会到Object  对象的prototype对象上寻找。因为所有的function和对象等引用类型都继承Object；这也就说明了为什么不是通过Object直接实例的对象（自定义类型）会有valueof（），toString（）等方法。


需要注意的是，子类有时需要重写父类的方法或者新增心得方法，这些都要 替换了原型之后(也就是实现继承之后)。-----------stu 指向Student的原型，Student的原型又指向了Person的原型。从而实现了stu 继承Student Student继承Person
function Person () {
    this.name = "person";
}
 
Person.prototype.getPersonName = function () {
    return this.name;
};
 
function Student () {
    this.studentname = "student";
}
 
// 继承了Person
Student.prototype = new Person();
   // 新增方法
Student.prototype.getStudentName = function () {
    return this.name;
};
   // 重写父类方法
Student.prototype.getPersonName = function () {
    return false;
};
 
var stu = new Student();
console.log(stu.getPersonName());           //false

还有一点需要注意的是：在通过原型链实现继承时，不能用对象字面量创建原型方法，因为这样会重写原型链。 刚刚把Person的实例赋值给原型，紧接着使用字面量导致出错。------->因为现在的原型包含的是一个Object的实例，不是Person的实例，原型链被切断。
function Person () {
    this.name = "person";
}
 
Person.prototype.getPersonName = function () {
    return this.name;
};
 
function Student () {
    this.studentname = "student";
}
 
// 继承了Person
Student.prototype = new Person();
// 使用字面量添加新方法，会导致Student.prototype = new Person(); 无效
Student.prototype = {
    getStudentName :function  () {
        return this.name;
    },
    otherMethod :function  () {
        return false;
    }
 
};
 
var stu = new Student();
console.log(stu.getPersonName());           //stu.getPersonName is not a function

会报错  stu.getPersonName is not a function 因为此时Student和Person已经没有关系了。
所以理想的继承方式是”寄生组合式继承“，所谓寄生组合式继承通过借用构造函数来继承属性（父类构造函数里的属性+方法），通过原型链的形式继承方法（父类原型里的方法）。
// 寄生组合式继承（理想的继承方式）
function inherPrototype (Subobject,Superobject) {
    var prototype = Superobject.prototype;
    prototype.constructor = Subobject;
    Subobject.prototype = prototype;
}
 
 
function Person (name) {
    this.name = name,
    this.hand = ["right-hand","left-hand"],
    this.say = function () {
        alert("hi");
    }
 
}
Person.prototype.sayName = function () {
    alert(this.name);
}
 
function Student (name,age) {
    Person.call(this,name);
    this.age = age;
}
// 实现继承
inherPrototype(Student,Person);
Student.prototype.sayAge = function () {
    alert(this.age);
}
 
var stu1 = new Student("jack",20);
 
 
// 继承了属性（构造函数里的属性+方法）
console.log(stu1.hand[0]);                  //----------->输出right-hand
stu1.say();                         //输出 hi
//  继承了原型里的方法
stu1.sayName();                     //输出 jack       

要实现继承无非就是拥有父类对象的方法和属性，即拥有一个父类的”模板副本“，inherPrototype（）方法做了如下三件事：1.创建父类的原型（prototype）副本，赋值给prototype  2.为创建的prototype副本添加constructor属性 ，弥补因为原型赋值而导致失去默认的constructor属性3.把这个副本赋值给子类原型。这样便实现了继承。
实战是解决问题的最佳途径，也是遇到问题的唯一途径，大家多多亲自制作才能更快更好的成长，另外多去借鉴别人的经验也是进步的捷径，希望能够给大家提供一点思路。