2018年Java，Web 和移动程序员学习的 12 个框架
我的图书馆
2018年Java，Web 和移动程序员学习的 12 个框架
新的一年已经开始，不知道大家有没有定好小目标。如果2018年还没有决定学什么，那么你来对地方了。在今天的文章中，我将分享一些你可以学习的最好框架，以提升你在移动和Web开发以及大数据技术方面的知识。在当今世界，对各种框架的了解是非常重要的。它们使你可以快速开发原型和实际项目。如果你在创业公司工作，那么你肯定希望能够立马装备一些炫酷的东西，那正是框架知识发光发热的地方。如果你被困在一些无聊的工作，比如启动和停止服务器，设置一些cron工作，回复相同的电子邮件，维护遗留的应用程序等，那么它也可以帮助你获得更好的工作，让你的事业提高到一个新的水平。在本文中，我分享了12个与Java开发、移动app开发、Web开发和大数据相关的有用框架。如果你认为还有值得Java和Web开发人员在2018年学习的好框架，那么请随时分享到评论中。1）Angular这是另一个JavaScript框架，也在我的2018年学习清单中。它提供了一个完全的客户端解决方案。你可以使用AngularJS在客户端创建动态网页。它提供了声明性模板，依赖注入，端到端工具，以及集成的最佳实践，以解决客户端的常见开发难题。由于它是一个JavaScript库，因此你可以使用标签将其包含在HTML页面中。它使用指令（Directives）扩展HTML属性，并使用表达式将数据绑定到HTML。因为Google支持Angular，所以在性能和定期更新方面你可以放心。我坚信AngularJS绝对不会短命，绝对值得你投入时间和精力。2）Node.js毫无疑问，JavaScript是排名第一的编程语言，而Node.js对此发挥了重要作用。传统上，JavaScript被用作客户端脚本语言，与HTML一起使用来提供客户端上的动态行为。它运行在Web浏览器上，但是Node.js允许你在服务器端运行JavaScript。Tye Node.js是一个开源和跨平台的JavaScript运行时环境，用于执行服务器端JavaScript代码。你可以使用Node.js在服务器端创建动态网页，然后将其发送到客户端。这意味着你可以用JavaScript开发一个从前端到后端的客户端-服务器端应用程序。3）Spring Boot我已经使用Spring框架许多年了，所以当我第一次被介绍到Spring Boot时，我完全被它相对匮乏的配置震惊到了。使用Spring Boot编写基于Spring的Java应用程序就像使用main()方法编写核心Java应用程序一样简单。尽管我已经尝试过Spring Boot，但我还没有掌握它，这就是为什么我需要在2018年学习Spring Boot的原因。4）ReactReact是用于构建用户界面的另一个JavaScript库或框架。它就像AngularJS，但由Facebook、Instagram、以及一个由个人开发人员和企业组成的社区维护。它允许Web开发人员创建大型网页应用程序，允许随时改变而无需重新加载页面。web开发世界被分成了Angular和React两个阵营，具体在哪个阵营取决于你选择的方面。大多数情况下，这是由情况决定的。例如，如果你工作于一个基于React的项目，那么显然，你需要学习React。5）Bootstrap这是用于设计网站和Web应用程序的另一个流行的开源前端Web框架。最初由Twitter带给我们的Bootstrap，提供了基于HTML和CSS的设计模板，用于排印，表单，按钮，导航和其他界面组件以及可选的JavaScript扩展。Bootstrap支持响应式Web设计，这意味着web页面布局可以根据浏览器的屏幕大小动态地调整。在移动领域中，BootStrap以其移动优先的设计理念引领潮流，着重于默认情况下的响应式设计。如果你是Web开发人员，却还不曾涉足Bootstrap，那么是时候在2018年学习了。6）jQuery这是另一个统治世界的JavaScript框架。jQuery一直是我的最爱，我建议每个开发者学习jQuery。它使得客户端脚本变得so easy。你可以做动画，发送HTTP请求，重新加载页面，以及通过写几行代码来执行客户端验证。7）Spring Security 5安全是无可替代的，2018年将更为重要。由于Spring Security已经成为Java世界中Web安全的代名词，因此更新到2018年最新版本的Spring Security非常有意义。Spring Security的新版本5.0包含许多bug修复和一个全新的OAuth 2.0模块。即使你不了解Spring Security，那么你也应该考虑在2018年学习它。8）Apache Hadoop大数据和自动化是2018年许多公司关注的重点，这就是为什么学习Hadoop和Spark等大数据技术变得至关重要。Apache Hadoop是一个允许使用简单编程模型在计算机集群中分布式处理大型数据集的框架。它旨在从单台服务器扩展到数千台机器，每台机器提供本地计算和存储。它基于流行的Map Reduce模式，是开发可靠、可扩展和分布式软件计算应用程序的关键。9）Apache Spark这是另一个日益普及的大数据框架。Apache Spark是一个快速的内存数据处理引擎，具有优雅和善于表达的开发API，使数据工作者能够高效地执行流、机器学习或需要快速迭代访问数据集的SQL工作负载。你可以将Spark用于ETL，机器学习和数据科学工作负载到Hadoop的内存计算。10）CordovaApache Cordova是最初由Nitobi创建的另一个移动应用程序开发框架。Adobe Systems在2011年收购了Nitobi，将其重新命名为PhoneGap，后来又发布了一个名为Apache Cordova的开源软件。它允许你使用标准的web技术——HTML5，CSS3和JavaScript——进行跨平台开发。11）FirebaseFirebase是Google的移动平台，可帮助你快速开发高品质的移动app并拓展业务。你可以选择Firebase作为Android或iOS应用程序的后端。如果你打算在2018年进入业务利润丰厚的移动应用程序开发，那么学习Firebase是一个非常棒的主意。12）XamarinXamarin是一种通过单一和共享C#代码库为所有平台快速制作移动应用程序，为每个平台构建自定义本地用户界面，或者使用Xamarin.Forms跨平台编写单个共享用户界面的方法。Xamarin由微软所有，并且很快成为为C、C ++和C＃开发人员创建移动应用程序的热门之选。如果你已经掌握C语言中的一种，并且正想涉足移动app开发的领域，那么我强烈建议你在2018年学习Xamarin。这就是2018年要学的东西。这些框架需求量很大，尤其是Spring，Node.js和AngularJS。学习这些框架不仅可以提高你找工作的机会，还可以打开众多的机会大门。即使你暂时不打算换工作，保持更新到最新和最伟大的技术也是职业成长的关键。所以，我建议你在2018年选择一些这样的框架并学习它们。如果你是Java开发者，那么Apache Spark是一个不错的选择，但是如果你对编程语言而不是框架或者库感兴趣的话，那么Kotlin看上去很赞。来源：http://www.codeceo.com/article/12-frameworks-java-web-mobile-developer-learn.html
[转]&[转]&[转]&[转]&[转]&[转]&
喜欢该文的人也喜欢上篇提到了高性能处理的关键是异步，而我们当中许多人依旧在使用同步模式的HttpClient访问第三方Web资源，我认为原因之一是：异步的HttpClient诞生较晚，许多人不知道；另外也可能是大多数Web程序其实不在意这点性能损失了。
而要自己实现一个异步的HttpClient则比较困难，通常都是自己开一个新的工作线程，利用HttpClient的同步去访问，完成后再回调这种形式，这样做其实不是真正的异步，因为依旧会有一个线程处于阻塞中，等待着第三方Web资源的返回。
而如今访问第三方Web资源的情景越来越多，最典型就是使用第三方登录平台，如QQ或微信等，我们需要访问腾讯的服务器去验证登录者的身份，根据我的经验，这个过程可能会阻塞好几秒钟，可看作是一个&长时间调用&，所以最好要使用异步方式。
OK，废话少说，要使用异步的HttpClient，请Maven中带上：
&dependency&
&groupId&org.apache.httpcomponents&/groupId&
&artifactId&httpasyncclient&/artifactId&
&version&4.1.1&/version&
&/dependency&
接下来是一个完整的Demo代码：
import org.apache.http.HttpR
import org.apache.http.client.methods.HttpG
import org.apache.http.concurrent.FutureC
import org.apache.http.impl.nio.client.CloseableHttpAsyncC
import org.apache.http.impl.nio.client.HttpAsyncC
import org.apache.http.util.EntityU
import java.io.IOE
import java.util.concurrent.CountDownL
public class Main {
public static void main(String[] argv) {
CloseableHttpAsyncClient httpclient = HttpAsyncClients.createDefault();
httpclient.start();
final CountDownLatch latch = new CountDownLatch(1);
final HttpGet request = new HttpGet("https://www.alipay.com/");
System.out.println(" caller thread id is : " + Thread.currentThread().getId());
httpclient.execute(request, new FutureCallback&HttpResponse&() {
public void completed(final HttpResponse response) {
latch.countDown();
System.out.println(" callback thread id is : " + Thread.currentThread().getId());
System.out.println(request.getRequestLine() + "-&" + response.getStatusLine());
String content = EntityUtils.toString(response.getEntity(), "UTF-8");
System.out.println(" response content is : " + content);
} catch (IOException e) {
e.printStackTrace();
public void failed(final Exception ex) {
latch.countDown();
System.out.println(request.getRequestLine() + "-&" + ex);
System.out.println(" callback thread id is : " + Thread.currentThread().getId());
public void cancelled() {
latch.countDown();
System.out.println(request.getRequestLine() + " cancelled");
System.out.println(" callback thread id is : " + Thread.currentThread().getId());
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
httpclient.close();
} catch (IOException ignore) {
&呃&&代码很简单，好像也没什么好说的了，稍作封装就可以实现如&getJson()&这样的方法。
也许你还注意到了，这个HttpClient跟同步的版本一样，直接支持https，但如果网站的证书是自签的，默认还是不行的，解决方法当然有，但代码有些麻烦，我觉得还不如直接买张证书来得简单，如果网站是你管的话。
阅读(...) 评论()优缺点分析 | 2018年最火热 Top 10 Java 框架，你该会哪些？优缺点分析 | 2018年最火热 Top 10 Java 框架，你该会哪些？冰彦乐居百家号原文出自|Dailyrazor翻译|QiQi2018年已经过去五分之一，不知道大家有没有朝定好小目标更加前进一点呢？在今天的文章中，我将分享一些值得了解的JavaWeb框架，以提升你 Web开发方面的知识。老话说的好，工欲善其事，必先利其器。选择一个好的 Web应用框架就像一把称手的兵器，可以助你披荆斩棘。我们今天就为大家整理了十佳 Java Web应用框架，并简单讨论一下它们的优缺点。(备注：排名不分先后）第一，大名鼎鼎的SpringMVC框架。Spring MVC框架堪称是一个教科书式的 MVC （模型Model、视图View和控制器Controller）框架，严格组照 MVC模式要求进行分层设计。经过多年的发展，Spring MVC已经发展成了一个 Web应用程序的全能架构。易用性方面， Spring MVC为 Web应用程序的开发和配置提供了有用的工具箱。扩展性方面， Spring MVC也以插件多而出名，大量优秀插件可供选择，如SOAP服务、REST API和安全认证。优点：强大的模块化功能，代码可读性高；可以通过 POJO （Plain Ordinary Java Object，简单的Java对象）对测试数据进行简单的注入；可以灵活使用DI(DependencyInjection，依赖注入，或者叫控制反转)；不同模块间是低耦合的（上面四点优点归根结底还是耦合度低）。缺点：对于新手来说，实现的难度比较大；学习曲线比较陡峭，即入门比较难。第二，JSF。它可以说是所有 Java框架中的与 Java关系最近的，因为它和Java都是 Oracle的嫡系部队。JSF也许并算不上最好的 Java框架，但是由于 Oracle的加持，JSF的文档是最全也最容易找到的。此外，由于 JSF已通过 JCP格式化为 JavaEE的一部分，所以你只要安装了 J2EE，就可以无障碍使用 JSF了。复杂的功能也能用JSF提供的大量工具和库来实现。借助 JSP(Java Server Pages)，JSF还可以支持不同的 Facelets和 XUL技术。优点：由于 JSF集成在 JavaEE中，对于使用 IDE的开发人员来说非常方便。缺点：入门门槛比较高，如果没有 Java Web的开发经历很难完整理解JSF。第三，Struts。Struts是Apache软件基金会（ASF）赞助的一个开源项目，也是基于 MVC模式进行设计的，但是不像 Spring MVC那么严格遵守 MVC模式，经常被视作一种变种。Struts是通过一系列接口和类来实现某些特定的功能，为 Java应用提供了网络框架。与传统的互联网功能不同，它可以创建动态响应。众人拾柴火焰高，在各个开源社区的共同努力下，Struts才有了今天的影响。当然，Struts常常被诟病为“万年漏洞王”，去年国内还因为新漏洞闹的沸沸扬扬，但仍然不能否定其是一个强大易用的框架。优点：原生支持I-18-N（即国际化，其来源是英文单词 internationalization的首末字符i和n，18为中间的字符数）；便捷的数据有效性验证和身份验证；支持模块化开发和集成插件。缺点：灵活性不足；安全性有待提高。第四，Hibernate ORM也是一个不能被忽略的优秀框架,属于使用 GNU通用公共许可证发行的自由开源软件。Hibernate是一套对象关系映射解决方案，能够建立面向对象模型与关系数据模型的映射。Hibernate对 JDBC进行了非常轻量级的对象封装，使 Java开发人员可以随心所欲的使用对象编程思维来操纵数据库。优点：移植性好，只需要修改极少量的代码修改实现与其他数据库通信；数据库不敏感，通吃MySQL, DB2和 Oracle等主流数据库；优秀的缓存机制（session缓存，二级缓存，查询缓存），对于那些改动不大且经常使用的数据，可以将它们放到缓存中，不必在每次使用时都去查询数据库，缓存机制对提升性能大有裨益；延迟加载（只有等系统需要使用集合属性时才从数据库装载关联的数据）。缺点：一旦断电，所有未存储就会丢失；重启非常慢。第五，GWT(GoogleWeb Toolki)是一个前端使用JavaScript，后端使用 Java的AJAX框架，以 Apache许可证2.0版本开放源码。GWT通过编译器将 Java代码编译成JavaScript，可以让开发人员只使用 Java就可以快速开发维护复杂但高性能的 JavaScript ，借此减轻开发人员负担。除了一些本地库之外，都可以用集成的 GWT Ant将 Java源码构建成 JavaScript。 GWT已经实现了大量代码跨平台复用，包括跨浏览器移植性、国际化、UI抽象化、书签、历史管理、远程程序调用和异步的代码。优点：入门容易；特别适合应用；在想要通过增加客户端负载从而减少服务器端负载，进而提升响应速度的web应用程序；借助各种各样的JavaScript库，开发人员可以充分利用GWT的能力；内置IDE能够直接重构Java密文/代码；由Google负责开发，前景光明。缺点：GWT是一个快速迭代的项目，版本太多，可能没法知道所有接口和方法；编译器执行效率比较慢；定义结构的时候必须使用专用的方法来执行。第六，Play框架是一种基于无状态（stateless）、Web友好和轻量级的架构，支持Scala和Java两种语言。它构建在 Akka （一个用Scala编写的分布式应用框架）上并利用了 Akka顶部设计的完全异步模型，为可高度伸缩的应用程序分配最小和可预测的资源（比如线程数、内存和CPU)。Play比较友好，开发人员可以通过文本编辑器和浏览器直接进行修改。此外，尽管它是无状态的，但它的规模是可以预见的。可以说，Play是为了因应现代移动和网络应用的需要而诞生的。优点：极大地提高了开发人员的生产率；配置、模板和java代码的更改可以快速完成重载；Play是在Netty基础上设计的，支持异步I/O；它是开源的；由Zenexity公司和Lightbend公司提供商业支持；Play可以在运行时处理错误。缺点：Play 2基本上是对Play 1的重写，比Python3.X和Python2.X的差距大多了，想想Python就知道了；它是围绕异步I/O构建的，你可能会得到一个不知名的内部类；无论是Play框架还是Akka的中文资料少之又少。第七，Vaadin是一个 Apache许可的开源 Java web应用程序项目，并拥有一个活跃的社区（https://vaadin.com/forum）。用 Vaadin开发的浏览器应用界面可以达到和桌面应用类似的效果，但和 Flash 、Silverlight不同的是，Vaddin应用无需在浏览器上安装任何插件。它支持纯Java开发环境，开发人员无需深入了解 HTML，XML或是JavaScipt。如果你曾经使用 Java开发过 Swing，SWT等应用，可以非常容易开始使用 Vaddin开发 Web应用。优点：只需要在服务器端编程；支持布局、侦听器和组件类型；支持各类插件；可以很方便地和Spring框架集成。缺点：不支持多窗口；自动创建的JS代码的不够精简。第八，Grails基于Groovy编程语言，是一个坚持己见、提倡用约定的默认设置代替复杂配置的框架。它与 JVM很好地融合，能够在提供强大功能的同时保持高效，包括异步编程、编译时元编程、运行时和领域专用语言（DSL，专注于某个应用程序领域的计算机语言）。Grails可以透明地、无缝地与 Java、Java EE容器和 JVM进行互操作和集成。优点：处理中小型项目的理想工具；提供一个快速的开发周期；提供丰富的插件；文档简单易懂的；安装过程很简单，新手也可以在短时间内构建应用程序；GORM（Grails ObjectRelational Mapping，Grails对象关系映射）的配置简单；管理CSS简单；动态配置特性，无需重新启动服务器即可更改配置。缺点：依赖JVM运行环境；多线程时候有时可能会有问题。第九，Wicket又称 Apache Wicket，一看这个名字，又是一个Apache基金会旗下的开源框架了。Wicket是一个基于组件的轻量级的 Java应用程序框架。Wicket使用遵循 XHTML标准的命名空间来支持 HTML模板。其特点在于对 Html和 Java代码进行了有效的分离（有利于程序员和美工的合作），基于规则的配置(减少了 XML等配置文件的使用)。优点：代码是用Java编写的；没有XML配置文件；没有返回键的问题；是一种简单Java对象为中心的编程；测试比较容易。缺点：发展前景比较不明确；基于事件的设计可能增加代码混乱的几率。第十，Vert.x框架是一个基于 JVM、轻量级、高性能的应用框架，基于事件驱动和异步，使用极少的核心线程里占用最小限度的硬件资源处理大量的高并发。Vert.x支持多种语言，例如Ceylon、Ruby、Groovy、JavaScript和Java，因此可以根据项目特性和团队技能灵活选择语言。优点：设置容易；Vert.x容器里强大的内核线程；为异步提供简单的方法和对象。缺点：一些硬件可能无法执行；支持语言太多，选择一门恰当的语言会让人头疼会。本文简要介绍了当前 10个最主流的JavaWeb框架的各自特性和优缺点。希望能对大家未来的学习和工作有所帮助。本文由百家号作者上传并发布，百家号仅提供信息发布平台。文章仅代表作者个人观点，不代表百度立场。未经作者许可，不得转载。冰彦乐居百家号最近更新：简介:本人有丰富的综合领域写作经验。作者最新文章相关文章对于我们开发的网站，如果网站的访问量非常大的话，那么我们就需要考虑相关的并发访问问题了。而并发问题是绝大部分的程序员头疼的问题，但话又说回来了，既然逃避不掉，
那我们就坦然面对吧~今天就让我们一起来研究一下常见的并发和同步吧。
　　为了更好的理解并发和同步，我们需要先明白两个重要的概念:同步和异步
&&&1、同步和异步的区别和联系
&　　所谓同步，可以理解为在执行完一个函数或方法之后，一直等待系统返回值或消息，这时程序是出于阻塞的，只有接收到
&&&&&&&&返回的值或消息后才往下执行其它的命令。
&&&&&&& 异步，执行完函数或方法后，不必阻塞性地等待返回值或消息，只需要向系统委托一个异步过程，那么当系统接收到返回
&&&&&&& 值或消息时，系统会自动触发委托的异步过程，从而完成一个完整的流程。
&&&&&&&& 同步在一定程度上可以看做是单线程，这个线程请求一个方法后就待这个方法给他回复，否则他不往下执行(死心眼)。
&&&&&&& 异步在一定程度上可以看做是多线程的(废话，一个线程怎么叫异步)，请求一个方法后，就不管了，继续执行其他的方法。
　　 &同步就是一件事，一件事情一件事的做。& & & &&&异步就是，做一件事情，不影响做其他事情。
例如：吃饭和说话，只能一件事一件事的来，因为只有一张嘴。& & & & & &但吃饭和听音乐是异步的，因为，听音乐并不影响我们吃饭。
&&&&&&& 对于Java程序员而言，我们会经常听到同步关键字synchronized，假如这个同步的监视对象是类的话，那么如果当一个对象
& & & & 访问类里面的同步方法的话，那么其它的对象如果想要继续访问类里面的这个同步方法的话，就会进入阻塞，只有等前一个对象
& & & & 执行完该同步方法后当前对象才能够继续执行该方法。这就是同步。相反，如果方法前没有同步关键字修饰的话，那么不同的对象
& & & & 可以在同一时间访问同一个方法，这就是异步。
&&&&&&& 在补充一下(脏数据和不可重复读的相关概念):
&&&&&&&脏数据
　　脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这
个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是脏数据(Dirty Data)，依据脏数据所做的操作可能是不正确的。
&　　不可重复读
　　不可重复读是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读
&2、如何处理并发和同步
& & & &&今天讲的如何处理并发和同步问题主要是通过锁机制。
& & & &我们需要明白，锁机制有两个层面。
& & & &一种是代码层次上的，如java中的同步锁，典型的就是同步关键字synchronized，这里我不在做过多的讲解，
& & & &感兴趣的可以参考:
& & & &另外一种是数据库层次上的，比较典型的就是悲观锁和乐观锁。这里我们重点讲解的就是悲观锁（传统的物理锁）和乐观锁。
& & & &悲观锁(Pessimistic Locking):&&& & &
& & & &悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自&外部系统的事务处理）修改持保守态度，因此，
& & & &在整个数据处理过程中，将数据处于锁定状态。
& & & &悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能&真正保证数据访问的排他性，否则，即使在本系统
& & & &中实现了加锁机制，也无法保证外部系&统不会修改数据）。&
& & & &一个典型的依赖数据库的悲观锁调用：&
& & & &select * from account where name=”Erica” for update
& & & &这条 sql 语句锁定了 account 表中所有符合检索条件（ name=”Erica” ）的记录。
& & & &本次事务提交之前（事务提交时会释放事务过程中的锁），外界无法修改这些记录。&& & & &Hibernate 的悲观锁，也是基于数据库的锁机制实现。&& & & &下面的代码实现了对查询记录的加锁：
& & & &String hqlStr ="from TUser as user where user.name='Erica'";
& & & & Query query = session.createQuery(hqlStr);
& &&& & query.setLockMode("user",LockMode.UPGRADE); // 加锁
& &&& &List userList = query.list();// 执行查询，获取数据
& & & &query.setLockMode&对查询语句中，特定别名所对应的记录进行加锁（我们为&TUser 类指定了一个别名 “user” ），这里也就是对
& & & 返回的所有 user 记录进行加锁。&
& & & 观察运行期 Hibernate 生成的 SQL 语句：&& & & select tuser0_.id as id, tuser0_.name as name, tuser0_.group_id& & & as group_id, tuser0_.user_type as user_type, tuser0_.sex as sex& & & from t_user tuser0_ where (tuser0_.name='Erica' ) for update& & &这里 Hibernate 通过使用数据库的 for update 子句实现了悲观锁机制。&& & & Hibernate 的加锁模式有：&& & & ? LockMode.NONE ： 无锁机制。&& & & ? LockMode.WRITE ： Hibernate 在 Insert 和 Update 记录的时候会自动获取& & & ? LockMode.READ ： Hibernate 在读取记录的时候会自动获取。&& & & 以上这三种锁机制一般由 Hibernate 内部使用，如 Hibernate 为了保证 Update& & & 过程中对象不会被外界修改，会在 save 方法实现中自动为目标对象加上 WRITE 锁。&& & & ? LockMode.UPGRADE ：利用数据库的 for update 子句加锁。&& & & ? LockMode. UPGRADE_NOWAIT ： Oracle 的特定实现，利用 Oracle 的 for& & & update nowait 子句实现加锁。&& & & 上面这两种锁机制是我们在应用层较为常用的，加锁一般通过以下方法实现：&& & & Criteria.setLockMode& & & Query.setLockMode& & & Session.lock& & & 注意，只有在查询开始之前（也就是 Hiberate 生成 SQL 之前）设定加锁，才会&& & & 真正通过数据库的锁机制进行加锁处理，否则，数据已经通过不包含 for update& & & 子句的 Select SQL 加载进来，所谓数据库加锁也就无从谈起。
& & & 为了更好的理解select... for update的锁表的过程，本人将要以mysql为例，进行相应的讲解
& & & 1、要测试锁定的状况，可以利用MySQL的Command Mode ，开二个视窗来做测试。
& & & & & 表的基本结构如下:
& & & & &&
& & & & &&&表中内容如下:
& & & & & &
& & & & & 开启两个测试窗口，在其中一个窗口执行select * from ta for update0
& & & & & 然后在另外一个窗口执行update操作如下图:
& & & & &&
& & & & & 等到一个窗口commit后的图片如下:
& & & & &&
& & & & & &到这里，悲观锁机制你应该了解一些了吧~
& & & & & &需要注意的是for update要放到mysql的事务中，即begin和commit中，否则不起作用。
& & & & & &至于是锁住整个表还是锁住选中的行，请参考:
& & & & & &
&&&&&&&&&& &至于hibernate中的悲观锁使用起来比较简单，这里就不写demo了~感兴趣的自己查一下就ok了~
& & & & & &
&&&&&&&& &乐观锁(Optimistic Locking):&&&&&&&&&&&&&&&& 相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依&靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之
而来的就是数据库&性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。&如一个金融系统，当某个操作员读取用户的数据，并在读出的用户数
据的基础上进&行修改时（如更改用户帐户余额），如果采用悲观锁机制，也就意味着整个操作过&程中（从操作员读出数据、开始修改直至提交修改结果的全
过程，甚至还包括操作&员中途去煮咖啡的时间），数据库记录始终处于加锁状态，可以想见，如果面对几&百上千个并发，这样的情况将导致怎样的后果。&乐
观锁机制在一定程度上解决了这个问题。
&&&&&&&& 乐观锁，大多是基于数据版本&& Version ）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通
过为数据库表增加一个 “version” 字段来&实现。&读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提&交数据的版本数据与数据
库表对应记录的当前版本信息进行比对，如果提交的数据&版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。对于上面修改用户帐户信息
的例子而言，假设数据库中帐户信息表中有一个&version 字段，当前值为 1 ；而当前帐户余额字段（ balance ）为 $100 。操作员 A 此时将其读出
（ version=1 ），并从其帐户余额中扣除 $50（ $100-$50 ）。&2 在操作员 A 操作的过程中，操作员 B 也读入此用户信息（ version=1 ），并&从其帐
户余额中扣除 $20 （ $100-$20 ）。&3 操作员 A 完成了修改工作，将数据版本号加一（ version=2 ），连同帐户扣&除后余额（ balance=$50 ），提交
至数据库更新，此时由于提交数据版本大&于数据库记录当前版本，数据被更新，数据库记录 version 更新为 2 。&4 操作员 B 完成了操作，也将版本号加一
（ version=2 ）试图向数据库提交数&据（ balance=$80 ），但此时比对数据库记录版本时发现，操作员 B 提交的&数据版本号为 2 ，数据库记录当前版
本也为 2 ，不满足 “ 提交版本必须大于记&录当前版本才能执行更新 “ 的乐观锁策略，因此，操作员 B 的提交被驳回。&这样，就避免了操作员 B 用基于
version=1 的旧数据修改的结果覆盖操作&员 A 的操作结果的可能。&从上面的例子可以看出，乐观锁机制避免了长事务中的数据库加锁开销（操作员 A
和操作员 B 操作过程中，都没有对数据库数据加锁），大大提升了大并发量下的系&统整体性能表现。&需要注意的是，乐观锁机制往往基于系统中的数据存储
逻辑，因此也具备一定的局&限性，如在上例中，由于乐观锁机制是在我们的系统中实现，来自外部系统的用户&余额更新操作不受我们系统的控制，因此可能
会造成脏数据被更新到数据库中。在&系统设计阶段，我们应该充分考虑到这些情况出现的可能性，并进行相应调整（如&将乐观锁策略在数据库存储过程中实
现，对外只开放基于此存储过程的数据更新途&径，而不是将数据库表直接对外公开）。&Hibernate 在其数据访问引擎中内置了乐观锁实现。如果不用考虑外
部系统对数&据库的更新操作，利用 Hibernate 提供的透明化乐观锁实现，将大大提升我们的&生产力。
User.hbm.xml
&?xml version="1.0"?&
&!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"&
&hibernate-mapping package="com.xiaohao.test"&
&class name="User"
table="user" optimistic-lock="version" &
&id name="id"&
&generator class="native" /&
&!--version标签必须跟在id标签后面--&
&version column="version" name="version"
&property name="userName"/&
&property name="password"/&
&/hibernate-mapping&
注意 version 节点必须出现在 ID 节点之后。&这里我们声明了一个 version 属性，用于存放用户的版本信息，保存在 User 表的version中&optimistic-lock 属性有如下可选取值：&? none无乐观锁&? version通过版本机制实现乐观锁&? dirty通过检查发生变动过的属性实现乐观锁&? all通过检查所有属性实现乐观锁&其中通过 version 实现的乐观锁机制是 Hibernate 官方推荐的乐观锁实现，同时也&是 Hibernate 中，目前唯一在数据对象脱离 Session 发生修改的情况下依然有效的锁机&制。因此，一般情况下，我们都选择 version 方式作为 Hibernate 乐观锁实现机制。
2 ． 配置文件hibernate.cfg.xml和UserTest测试类
&& hibernate.cfg.xml
&!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"&
&hibernate-configuration&
&session-factory&
&!-- 指定数据库方言 如果使用jbpm的话，数据库方言只能是InnoDB--&
&property name="dialect"&org.hibernate.dialect.MySQL5InnoDBDialect&/property&
&!-- 根据需要自动创建数据表 --&
&property name="hbm2ddl.auto"&update&/property&
&!-- 显示Hibernate持久化操作所生成的SQL --&
&property name="show_sql"&true&/property&
&!-- 将SQL脚本进行格式化后再输出 --&
&property name="format_sql"&false&/property&
&property name="current_session_context_class"&thread&/property&
&!-- 导入映射配置 --&
&property name="connection.url"&jdbc:mysql:///user&/property&
&property name="connection.username"&root&/property&
&property name="connection.password"&123456&/property&
&property name="connection.driver_class"&com.mysql.jdbc.Driver&/property&
&mapping resource="com/xiaohao/test/User.hbm.xml" /&
&/session-factory&
&/hibernate-configuration&
UserTest.java
package com.xiaohao.
import org.hibernate.S
import org.hibernate.SessionF
import org.hibernate.T
import org.hibernate.cfg.C
public class UserTest {
public static void main(String[] args) {
Configuration conf=new Configuration().configure();
SessionFactory sf=conf.buildSessionFactory();
Session session=sf.getCurrentSession();
Transaction tx=session.beginTransaction();
User user=new User("小浩","英雄");
session.save(user);
session.createSQLQuery("insert into user(userName,password) value('张英雄16','123')")
.executeUpdate();
User user=(User) session.get(User.class, 1);
user.setUserName("221");
session.save(user);
System.out.println("恭喜您，用户的数据插入成功了哦~~");
tx.commit();
每次对 TUser 进行更新的时候，我们可以发现，数据库中的 version 都在递增。
下面我们将要通过乐观锁来实现一下并发和同步的测试用例:
这里需要使用两个测试类，分别运行在不同的虚拟机上面，以此来模拟多个用户同时操作一张表,同时其中一个测试类需要模拟长事务
UserTest.java
package com.xiaohao.
import org.hibernate.S
import org.hibernate.SessionF
import org.hibernate.T
import org.hibernate.cfg.C
public class UserTest {
public static void main(String[] args) {
Configuration conf=new Configuration().configure();
SessionFactory sf=conf.buildSessionFactory();
Session session=sf.openSession();
Session session2=sf.openSession();
User user=(User) session.createQuery(" from User user where user=5").uniqueResult();
User user2=(User) session.createQuery(" from User user where user=5").uniqueResult();
System.out.println(user.getVersion());
System.out.println(user2.getVersion());
Transaction tx=session.beginTransaction();
user.setUserName("101");
tx.commit();
System.out.println(user.getVersion());
System.out.println(user2.getVersion());
System.out.println(user.getVersion()==user2.getVersion());
Transaction tx2=session2.beginTransaction();
user2.setUserName("4468");
tx2.commit();
UserTest2.java
package com.xiaohao.
import org.hibernate.S
import org.hibernate.SessionF
import org.hibernate.T
import org.hibernate.cfg.C
public class UserTest2 {
public static void main(String[] args) throws InterruptedException {
Configuration conf=new Configuration().configure();
SessionFactory sf=conf.buildSessionFactory();
Session session=sf.openSession();
Session session2=sf.openSession();
User user=(User) session.createQuery(" from User user where user=5").uniqueResult();
Thread.sleep(10000);
User user2=(User) session.createQuery(" from User user where user=5").uniqueResult();
System.out.println(user.getVersion());
System.out.println(user2.getVersion());
Transaction tx=session.beginTransaction();
user.setUserName("100");
tx.commit();
System.out.println(user.getVersion());
System.out.println(user2.getVersion());
System.out.println(user.getVersion()==user2.getVersion());
Transaction tx2=session2.beginTransaction();
user2.setUserName("4468");
tx2.commit();
操作流程及简单讲解: 首先启动UserTest2.java测试类，在执行到Thread.sleep(10000);这条语句的时候，当前线程会进入睡眠状态。在10秒钟之内
&&&&&&&&&&&&&&&&&&&&&&&&&&& 启动UserTest这个类，在到达10秒的时候，我们将会在UserTest.java中抛出下面的异常:
Exception in thread "main" org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect): [com.xiaohao.test.User#5]
at org.hibernate.persister.entity.AbstractEntityPersister.check(AbstractEntityPersister.java:1932)
at org.hibernate.persister.entity.AbstractEntityPersister.update(AbstractEntityPersister.java:2576)
at org.hibernate.persister.entity.AbstractEntityPersister.updateOrInsert(AbstractEntityPersister.java:2476)
at org.hibernate.persister.entity.AbstractEntityPersister.update(AbstractEntityPersister.java:2803)
at org.hibernate.action.EntityUpdateAction.execute(EntityUpdateAction.java:113)
at org.hibernate.engine.ActionQueue.execute(ActionQueue.java:273)
at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:265)
at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:185)
at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:321)
at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:51)
at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:1216)
at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:383)
at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:133)
at com.xiaohao.test.UserTest2.main(UserTest2.java:21)
&UserTest2代码将在 tx.commit() 处抛出 StaleObjectStateException 异&常，并指出版本检查失败，当前事务正在试图提交一个过期数据。通过捕捉这个异常，我&们就可以在乐观锁校验失败时进行相应处理
&3、常见并发同步案例分析
&&& 案例一:订票系统案例，某航班只有一张机票，假定有1w个人打开你的网站来订票，问你如何解决并发问题(可扩展到任何高并发网站要考虑
&&&&&&&&&&&&&& 的并发读写问题)
&&& 问题，1w个人来访问，票没出去前要保证大家都能看到有票，不可能一个人在看到票的时候别人就不能看了。到底谁能抢到，那得看这个人的“运气”（网
&&&&&&&&&&&& 络快慢等）
其次考虑的问题，并发，1w个人同时点击购买，到底谁能成交？总共只有一张票。
首先我们容易想到和并发相关的几个方案 ：
锁同步：同步更多指的是应用程序的层面，多个线程进来，只能一个一个的访问，java中指的是syncrinized关键字。锁也有2个层面，一个是java中谈到的对
象锁，用于线程同步；另外一个层面是数据库的锁；如果是分布式的系统，显然只能利用数据库端的锁来实现。
假定我们采用了同步机制或者数据库物理锁机制，如何保证1w个人还能同时看到有票，显然会牺牲性能，在高并发网站中是不可取的。使用hibernate后我们
提出了另外一个概念：乐观锁、悲观锁（即传统的物理锁）；
采用乐观锁即可解决此问题。乐观锁意思是不锁定表的情况下，利用业务的控制来解决并发问题，这样即保证数据的并发可读性又保证保存数据的排他性，保
证性能的同时解决了并发带来的脏数据问题。
hibernate中如何实现乐观锁：
前提：在现有表当中增加一个冗余字段，version版本号, long类型
1）只有当前版本号》=数据库表版本号，才能提交
2）提交成功后，版本号version ++
实现很简单：在ormapping增加一属性optimistic-lock="version"即可，以下是样例片段
&hibernate-mapping&
&class name="com.insigma.stock.ABC"&optimistic-lock="version"&table="T_Stock" schema="STOCK"&
案例二、股票交易系统、银行系统，大数据量你是如何考虑的
首先，股票交易系统的行情表，每几秒钟就有一个行情记录产生，一天下来就有（假定行情3秒一个） 股票数量×20×60*6 条记录，一月下来这个表记录数
量多大？ oracle中一张表的记录数超过100w后 查询性能就很差了，如何保证系统性能？
再比如，中国移动有上亿的用户量，表如何设计？把所有用于存在于一个表么？
所以，大数量的系统，必须考虑表拆分-（表名字不一样，但是结构完全一样），通用的几种方式：（视情况而定）
1）按业务分，比如 手机号的表，我们可以考虑 130开头的作为一个表，131开头的另外一张表 以此类推
2）利用oracle的表拆分机制做分表
3）如果是交易系统，我们可以考虑按时间轴拆分，当日数据一个表，历史数据弄到其它表。这里历史数据的报表和查询不会影响当日交易。
当然，表拆分后我们的应用得做相应的适配。单纯的or-mapping也许就得改动了。比如部分业务得通过存储过程等
此外，我们还得考虑缓存
这里的缓存，指的不仅仅是hibernate，hibernate本身提供了一级二级缓存。这里的缓存独立于应用，依然是内存的读取，假如我们能减少数据库频繁的访
问，那对系统肯定大大有利的。比如一个电子商务系统的商品搜索，如果某个关键字的商品经常被搜，那就可以考虑这部分商品列表存放到缓存（内存中
去），这样不用每次访问数据库，性能大大增加。
简单的缓存大家可以理解为自己做一个hashmap，把常访问的数据做一个key，value是第一次从数据库搜索出来的值，下次访问就可以从map里读取，而不
读数据库；专业些的目前有独立的缓存框架比如memcached 等，可独立部署成一个缓存服务器。
4、常见的提高高并发下访问的效率的手段
&&&&& 首先要了解高并发的的瓶颈在哪里？
&&&& 1、可能是服务器网络带宽不够
&&&& 2.可能web线程连接数不够
&&&&&3.可能数据库连接查询上不去。
&&&& 根据不同的情况，解决思路也不同。
像第一种情况可以增加网络带宽，DNS域名解析分发多台服务器。
负载均衡，前置代理服务器nginx、apache等等
数据库查询优化，读写分离，分表等等
&& 最后复制一些在高并发下面需要常常需要处理的内容:
尽量使用缓存，包括用户缓存，信息缓存等，多花点内存来做缓存，可以大量减少与数据库的交互，提高性能。
用jprofiler等工具找出性能瓶颈，减少额外的开销。
优化数据库查询语句，减少直接使用hibernate等工具的直接生成语句（仅耗时较长的查询做优化）。
优化数据库结构，多做索引，提高查询效率。
统计的功能尽量做缓存，或按每天一统计或定时统计相关报表，避免需要时进行统计的功能。
能使用静态页面的地方尽量使用，减少容器的解析（尽量将动态内容生成静态html来显示）。
解决以上问题后，使用服务器集群来解决单台的瓶颈问题。
java高并发，如何解决，什么方式解决
之前我将高并发的解决方法误认为是线程或者是队列可以解决，因为高并发的时候是有很多用户在访问，导致出现系统数据不正确、丢失数据现象，所以想到 的是用队列解决，其实队列解决的方式也可以处理，比如我们在竞拍商品、转发评论微博或者是秒杀商品等，同一时间访问量特别大，队列在此起到特别的作用，将 所有请求放入队列，以毫秒计时单位，有序的进行，从而不会出现数据丢失系统数据不正确的情况。
今天我经过查资料，高并发的解决方法有两种:
一种是使用缓存、另一种是使用生成静态页面；还有就是从最基础的地方优化我们写代码减少不必要的资源浪费：
1.不要频繁的new对象,对于在整个应用中只需要存在一个实例的类使用单例模式.对于String的连接操作,使用StringBuffer或者StringBuilder.对于utility类型的类通过静态方法来访问。
2. 避免使用错误的方式,如Exception可以控制方法推出,但是Exception要保留stacktrace消耗性能,除非必要不要使用 instanceof做条件判断,尽量使用比的条件判断方式.使用JAVA中效率高的类,比如ArrayList比Vector性能好。
首先缓存技术我一直没有使用过，我觉得应该是在用户请求时将数据保存在缓存中，下次请求时会检测缓存中是否有数据存在，防止多次请求服务器，导致服务器性能降低，严重导致服务器崩溃，这只是我自己的理解，详细的资料还是需要在网上收集；
使用生成静态页面我想大家应该不模式，我们见过很多网站当在请求的时候页面的最后已经变了，如”该页面其实是一个服务器请求地址，在转换成htm后，访问速度将提升，因为静态页面不带有服务器组件；在这里我就多多介绍一下：
一、什么是页面静态化：
简 单的说，我们如果访问一个链接 ,服务器对应的模块会处理这个请求，转到对应的jsp界面，最后生成我们想要看到的数据。这其中的缺点是显而易见的：因为每次请求服务器都会进行处理，如 果有太多的高并发请求，那么就会加重应用服务器的压力，弄不好就把服务器 搞down 掉了。那么如何去避免呢？如果我们把对 test.do 请求后的结果保存成一个 html 文件，然后每次用户都去访问 ,这样应用服务器的压力不就减少了？
那么静态页面从哪里来呢？总不能让我们每个页面都手动处理吧？这里就牵涉到我们要讲解的内容了，静态页面生成方案… 我们需要的是自动的生成静态页面，当用户访问 ,会自动生成 test.html ,然后显示给用户。
二、下面我们再简单介绍一下要想掌握页面静态化方案应该掌握的知识点：
1、&基础- URL Rewrite
什么是 URL Rewrite 呢 ? URL 重写。用一个简单的例子来说明问题：输入网址 ,但是实际上访问的却是 abc.com/test.action,那我们就可以说 URL 被重写了。这项技术应用广泛，有许多开源的工具可以实现这个功能。
2、&基础- Servlet & web.xml
如果你还不知道 web.xml 中一个请求和一个 servlet 是如何匹配到一起的，那么请搜索一下 servlet 的文档。这可不是乱说呀，有很多人就认为 /xyz/*.do 这样的匹配方式能有效。
如果你还不知道怎么编写一个 servlet ,那么请搜索一下如何编写 servlet.这可不是说笑呀，在各种集成工具漫天飞舞的今天，很多人都不会去从零编写一个 servlet了。
三、基本的方案介绍
其中，对于 URL Rewriter的部分，可以使用收费或者开源的工具来实现，如果 url不是特别的复杂，可以考虑在 servlet 中实现，那么就是下面这个样子：
总 结：其实我们在开发中都很少考虑这种问题，直接都是先将功能实现，当一个程序员在干到1到2年，就会感觉光实现功能不是最主要的，安全性能、质量等等才是 一个开发人员最该关心的。今天我所说的是高并发。
我的解决思路是：
1、采用分布式应用设计
2、分布式缓存数据库
3、代码优化
Java高并发的例子：
具体情况是这样：&通过java和数据库，自己实现序列自动增长。实现代码大致如下：&id_table表结构,&主要字段：
varchar2(16);
number(16,0);
varchar2(4);
public synchronized String nextStringValue(String id){
SqlSession sqlSess = SqlSessionUtil.getSqlSession();
sqlSess.update("update id_table set id_val = id_val + 1 where id_name="+id);
Map map = sqlSess.getOne("select id_name, id_prefix, id_val from id_table where id_name="+ id);
BigDecimal val = (BigDecimal) map.get("id_val");
//id_val是具体数字，rePack主要是统一返回固定长度的字符串；如：Y0000001, F0000001, T0000001等
String idValue = rePack(val, map);
return idV
//公共方法
　　public class IdHelpTool{
public static String getNextStringValue(String idName){
return getXX().nextStringValue(idName);
具体使用者，都是通过类似这种方式：IdHelpTool.getNextStringValue("PAY_LOG");来调用。问题：&&&&&&（1）&当出现并发时，&有时会获取重复的ID；&&&&&&（2）&由于服务器做了相关一些设置，有时调用这个方法，好像还会导致超时。&&&&&&&&&为了解决问题(1),&考虑过在方法getNextStringValue上，也加上synchronized&，&同步关键字过多，会不会更导致超时？跪求大侠提供个解决问题的大概思路！！！
解决思路一：
1、推荐&https://github.com/adyliu/idcenter2、可以通过第三方redis来实现。
解决思路一：
1、出现重复ID，是因为脏读了，并发的时候不加&synchronized&&比如会出现问题2、但是加了&synchronized&&，性能急剧下降了，本身&java&就是多线程的，你把它单线程使用，不是明智的选择，同时，如果分布式部署的时候，加了&synchronized&&也无法控制并发3、调用这个方法，出现超时的情况，说明你的并发已经超过了数据库所能处理的极限，数据库无限等待导致超时基于上面的分析，建议采用线程池的方案，支付宝的单号就是用的线程池的方案进行的。数据库&update&不是一次加1，而是一次加几百甚至上千，然后取到的这&1000个序号，放在线程池里慢慢分配即可，能应付任意大的并发，同时保证数据库没任何压力。
阅读(...) 评论()}