2014年4月23日 星期三

等Braum的Freljord的心,揭示

等Braum的Freljord的心,揭示


該Freljord的冷凍峰數百年來懲罰弱者。但由於這些擔心冰川的土地承載體弱的墳墓,為強大的,土地是一個搖籃,這僅僅是提升強人成為真正​​的冠軍的地方。等Braum的故事開始在這裡,和他的力量和堅韌成長,所以也做了他的傳奇。如今,他的壯舉激勵所有從最貧窮的農民到入侵者的激烈。當他準備承擔他的盾上陣再次,他去知道他攜帶的Freljord的人與他的希望和崇拜。

技能

被動:震盪吹燈

等Braum的基本攻擊申請震盪的打擊。一旦第一個堆棧被應用,從等Braum所有基本的攻擊和他的盟友施加進一步的堆棧。目標是維持4段都驚呆了,並受到魔法傷害。被打暈後,等Braum不能吹燈震盪再次溫和持續時間應用到自己的目標。

問:冬天的咬

等Braum驅使他在一條直線上skillshot盾凍結的冰,造成魔法傷害(基於等Braum的最大生命值),減緩和應用堆棧震盪吹燈的第一目標命中。

W:站在我身後

等Braum躍起到附近盟友的幫助下,他的目標和他們最接近的敵方英雄之間的定位自己,並授予兩個等Braum和他的目標點的護甲和魔法基於他的總護甲和魔法抗性抵抗。

E:堅不可摧

等Braum提高他的盾在目標方向,否定從屏蔽件的方向上的第一次攻擊的破壞和減少的所有後續攻擊的破壞,只要將屏蔽被抬起。等Braum 攔截彈與堅不可摧,使他們打他,然後被銷毀。他還獲得了一個未成年人的速度增加,直到他降低了他的盾牌。

記:冰川裂縫

等Braum抨擊他的盾牌在地上,散發出一股巨大的遠射skillshot的敲起來,破壞前留下一個強烈的緩慢場抓到所有的敵人。

遊戲

等Braum是一個強大而彈性的混戰支持,能夠使改變遊戲規則的劇本,同時節省他的團隊從敵人攻擊的彈幕。他形成了共生的債券,他打架旁邊的神射手,形成兩隊之間的牆,跳躍到他的盟友的幫助下,他轉變成為遊戲後期的坦克。

博特車道

在車道,等Braum功能最有效地為反動或投機取巧的支持,不斷在尋找機會,震盪吹燈向敵人二人。準確使用冬天的撕咬觸發誰已經從他們的走狗波逛到目標的標誌,而等Braum可以跳躍回到了他神射手的遠程安全與站在後面我才標記侵略性的敵人基本攻擊。申請震盪吹燈後,等Braum和他的射手有兩個堅實的選擇:要么跟進難,並嘗試激活眩暈,或區域中的敵人,並採取了積極的定位。震盪吹燈是強大到足以贏得幾乎所有的行業,而引發眩暈的威脅,作為一個強大的威懾力,迫使敵人射手遠離寶貴的奴才黃金。等Braum的過程中友好ganks也是一個強大的資產:按請速他的打野帶支架在我身後,等Braum的抽到了敵人二人的心臟。他們已經被標記為震盪吹燈後,打野的額外攻擊加速的眩暈,並幫助安全殺害。
不過,雖然等Braum是在進攻無可否認有用的,他是一個絕對的巨人防守時。由站在後面我提供的額外防禦都有幫助等Braum和他的神射手生存,否則致命傷害,同時具有堅不可摧所有的傷害時正確定位完全屏蔽他的盟友的潛力。當被激活時,堅不可摧的保護所有的盾牌後面等Braum的盟友從基本的攻擊和針對性和直通狀內翻“穿刺箭,塔里克的炫,和Caitlyn的Piltover睦能力,但不是放在像Nidalee的Bushwhack或斯溫的Nevermove能力。更重要的是,等Braum可以移動,同時使用堅不可摧的,這意味著他可以用他的盟友重新定位,因為他們的頭往自己的塔的安全,或為敵人隊伍移動到左右兩側的防護罩。等Braum還能夠繼續攻擊和鑄造能力,而他用盾牌堅不可摧-登陸緩慢的從冬天的撕咬而搬回阻止敵人junglers和射手更進一步。
等Braum收益固體或引發後續的潛力,一旦他打六級和解鎖冰川裂縫,提供友好的junglers擁有龐大的連鎖和慢容易ganking目標。如果等Braum的希望切斷他的目標的退路,他可以快速地站在我身後射擊冰川裂縫之前,重新定位的背後他的目標。能力的緩慢場大,強大到足以迫使閃爍,安全殺死。最後,冰川裂縫是同樣強大的脫離工具,在正確瞄準廢止追逐。

Teamfights

大約等Braum的更多的盟友,越他的盾牌眼前一亮。在小規模的小規模戰鬥,他一個箭步躥在他的盟友面前與站在後面我用堅不可摧來阻止挑嘗試並享受後續的損害之前。應他的團隊寡不敵眾,冰裂縫又是一個強大的脫離能力,特別是在叢林中的狹窄通道。或者,當更強大的散兵群,一個很好瞄準冬之咬放緩和適用的震盪吹燈,除了保證一殺等Braum的一部分。
而其他支持在敵人隊伍最好的操作在他們的團隊或深,等Braum功能最好的兩支球隊之間的物理牆壁,浸泡了堅不可摧的傷害,而他的球隊的損害經銷商開始工作。在冬天的撕咬低冷卻時間幫助等Braum既緩慢接近並逃離敵人而設立的震盪吹燈他的團隊。他的被動是這裡最強的 - 由兩個隊之間浮動,等Braum的能夠使用敵人的坦克和戰機的基本攻擊,因為他擊中了敵人的防線與冬之咬,可能設立暈眩針對整個敵方隊伍。與此同時,站在我身後給了等Braum突然波速他需要鏢給隊友,保護他們不受傷害與堅不可摧,它有扭轉,即使是最可悲的teamfights,還是保護他的squishies時,他們受到攻擊的可能性。最後,通過敵隊發動分裂冰川裂縫和(字面意思)減慢他們的希望協調的攻擊,給等Braum和他的盟友的機會,在移動和清理。

協同效應

用效果很好:

鬥爭反對:

  • 阿什

    通過減緩她的敵人,阿什給等Braum他冬天的撕咬蒙上了更容易的目標。同樣,兩個可配對冰川裂縫和魔法水晶箭一起完全癱瘓敵人和所有,但保證六級殺。

  • Zyra

    Zyra擁有一個工具包,輕而易舉地繞過等Braum的防禦。通過種植他身後的種子,她能否定堅不可摧的致命布盧姆。抓根也圈套等Braum,防止他保護他的神射手與站在後面我。

  • Caitlyn

    隨著她的無與倫比的範圍,Caitlyn最好的把握等Braum的被動,震盪的打擊。用聰明的時機,等Braum也可以使用站在後面我為Caitlyn火災90口徑淨,必要時幫助兩國逃生和潛水。


  • Vayne

    Vayne的得到了一些技巧了她的袖子斷言她的支配權等Braum。翻滾的低冷卻時間讓她躲閃冬之咬相對容易,而譴責投擲等Braum回來,即使他的屏蔽與堅不可摧,讓Vayne進入她的敵人神射手。

  • Ezreal

    Ezreal的秘術射擊適用於重災區的影響,這意味著一旦等Braum的應用震盪吹燈,Ezreal可以從距離進一步增加棧與他問:這樣做的純粹的威脅就足以迫使大多數的敵人遠離養殖。

  • 俊秀

    露露能出位置堅不可摧通過鑄造幫助,pix的!對等Braum或他的射擊關閉Glitterlance傷害並減緩前兩個射手。






冠軍見解

等Braum,由RiotWrekz設計
如同所有的冠軍,我們設計等Braum填寫傳奇冠軍池聯盟的特定差距。具體地講,他是第一個真正的坦克支援,我們已經創建了,誰需要命中為自己的球隊一個冠軍。我們已經有足夠的防禦支架-像娜美,索拉卡,珍娜等冠軍-誰否定通過治愈或盾牌的傷害,隨著戰鬥機的支持像利昂娜和阿利斯塔爾,誰是一般偉大的開始teamfights潛水前深入敵隊和干擾盡可能。等Braum的不同的東西:他是一個坦克遊戲支持誰是變相的命中為他的球隊,因此需要新的思維方式,位置和遊戲風格,以最傳統的支持。
關鍵等Braum的獨特的遊戲風格是堅不可摧的,他的E。這是一個積極的防禦,類似於康夫的風牆,但同時康夫的能力的創建,使他不得不保護自己的手段(團隊工具被認為是一種次要的獎金) ,我們專門設計堅不可摧,這樣等Braum可以保護他的團隊。它使等Braum不同,因為他-比其他任何冠軍-創建安全區在他身後。在整個比賽中,首先由拉寧在保護他的神射手,然後通過保護他的整個團隊和後期遊戲中坦克。而其他支持,專注於拋光,癒合或中斷,等Braum填補了兩隊之間的獨特作用,同時為自己的球隊的損害首當其衝,讓他損害經銷商做自己的事情。
這個職位他從字面上兩隊之間,並且給了我們一些有趣的設計問題來回答。具體來說,是怎麼回事就在戰鬥防禦近身的支持貢獻時,他有傷害有限,只能降落在敵人的前線仡基本攻擊?這是我們帶來了他的被動,震盪吹燈,和Q,冬之咬。等Braum可以騷擾,同時保護,不一定要通過自己的力量,而是通過應用震盪吹燈到敵方目標。這極大地放大他的球隊的同時保持等Braum的定位貫穿始終teamfights力量。雖然等Braum不能輕易騷擾敵人的防線(冬之咬只影響它擊中第一個敵人,和等Braum的基本攻擊是近戰),當他的盟友得到被敵方戰機和坦克跳了起來,他可以快速地站在後面我才重新定位脫皮與震盪吹燈多個目標。
我們很高興地看到你們做等Braum的。如果你有興趣在試探他演活了發布之前,進入筆試模式,並給他一掄。我們很想得到您的反饋!

2014年4月17日 星期四

Setting Bean Properties and Initializing Beans

Setting Bean Properties
Bean properties are set using the setProperty element. This element requires a bean
name (from the ID in the useBean element), a property, and a value attribute, as shown
in the following:
<jsp:setProperty name=”<bean name>”
➥ property=”<property name>” value=”<expression>”/>
To set the name of the example NameBean to winston, you would use the following:
<jsp:setProperty name=”myBean” property=”name” value=”winston”/>
As with getProperty, the bean method can be called explicitly from a Java scriptlet:
<% myBean.setName(“winston”); %>

A useful feature of the setProperty tag is that bean properties can also be initialized
from the HTTP request parameters. This is accomplished by using a param attribute
rather than the value attribute:
<jsp:setProperty name=”<bean name>” property=”<property name>” param=”<name>”/>
The value of the named parameter is used to set the appropriate bean property. To use a
request parameter called name to set the NameBean property of the same name, you could
use the following:

<jsp:setProperty name=”myBean” property=”name” param=”name”/>

In fact, the param attribute can be omitted if the property name is the same as the request
parameter name. So the previous example could have put more succinctly as follows:
<jsp:setProperty name=”myBean” property=”name”/>
A last form of the setProperty bean is employed when multiple parameters are used to
initialize several bean properties. If the property name is set to *, all of the form request
parameters are used to initialize bean properties with the same name:
<jsp:setProperty name=”myBean” property=”*”/>

Initializing Beans 

Some beans require properties to be defined to initialize the bean. There is no mecha-
nism for passing in initial values for properties in the jsp:useBean element, so a syntac-
tic convention is used instead.

Conventionally, if a bean must have properties defined before it can be used on the Web
page, the jsp:useBean is defined with an element body and the jsp:setProperty tags
are defined in the useBean body to initialize the required properties.

For example, assuming that the simple NameBean example requires the name to be initial-
ized, the following useBean syntax would be used:
<jsp:useBean id=”myBean” class=”NameBean” scope=”request” >
<jsp:setProperty name=”myBean” property=”name” value=”winston”/>
</jsp:useBean>


In fact, the param attribute can be omitted if the property name is the same as the request
parameter name. So the previous example could have put more succinctly as follows:
<jsp:setProperty name=”myBean” property=”name”/>
A last form of the setProperty bean is employed when multiple parameters are used to
initialize several bean properties. If the property name is set to *, all of the form request
parameters are used to initialize bean properties with the same name:
<jsp:setProperty name=”myBean” property=”*”/>
The bean must define a property for every parameter in the HTTP request;
otherwise, an error occurs.

Initializing Beans 
Some beans require properties to be defined to initialize the bean. There is no mecha-
nism for passing in initial values for properties in the jsp:useBean element, so a syntac-
tic convention is used instead.

Conventionally, if a bean must have properties defined before it can be used on the Web
page, the jsp:useBean is defined with an element body and the jsp:setProperty tags
are defined in the useBean body to initialize the required properties.
For example, assuming that the simple NameBean example requires the name to be initial-
ized, the following useBean syntax would be used:
<jsp:useBean id=”myBean” class=”NameBean” scope=”request” >
<jsp:setProperty name=”myBean” property=”name” value=”winston”/>
</jsp:useBean>

Using a Bean with the Agency Case Study

The next example uses the Agency case study code and refactors the name.jsp Web page
shown in Listing 13.6 to use a JavaBean. This time, you will use a bean to hide the com-
plex JNDI lookup and type casting needed to access the agency Session EJB.
The new JSP page is shown in Listing 13.9.


1: <HTML>
2: <TITLE>Agency Name</TITLE>
3: <BODY>4: <jsp:useBean id=”agency” class=”web.AgencyBean” scope=”request” />
5: <H1><jsp:getProperty name=”agency” property=”agencyName”/></H1>
6: </BODY>
7: </HTML>
This is much simpler for a non-Java developer to work with. All of the code required to
create the EJB using its JNDI name has been spirited away into a JavaBean of class
web.AgencyBean. This bean does not have any properties but simply defines a large num-
ber of business methods whose only purpose is to delegate behavior to the underlying
agency Session bean.


LISTING 13.10 Full Text of web.AgencyBean.java
1: package web;
2:
3: import java.rmi.*;
4: import java.util.* ;
5: import javax.ejb.* ;
6: import javax.naming.* ;
7:
8: import agency.*;
9:
10: public class AgencyBean
11: {
12:     Agency agency;
13:
14:     public AgencyBean ()
➥ throws NamingException, RemoteException, CreateException {
15:         InitialContext ic = null;
16:         ic = new InitialContext();
17:         AgencyHome agencyHome =
➥ (AgencyHome)ic.lookup(“java:comp/env/ejb/Agency”);
18:         agency = agencyHome.create();
19:     }
20:
21:     public String getAgencyName() throws RemoteException {
22:         return agency.getAgencyName();
23:     }
24:
25:     public Collection findAllApplicants() throws RemoteException {
26:         return agency.findAllApplicants();
27:     }
28:    

2014年4月16日 星期三

JSP Syntax and Structure

JSP Syntax and Structure
Before writing your first JSP, you need to gain an understanding of the syntax and the
structure of a JSP.As you have seen, JSP elements are embedded in static HTML. Like HTML, all JSP ele-
ments are enclosed in open and close angle brackets (< >). Unlike HTML, but like XML,
all JSP elements are case sensitive.

JSP elements are distinguished from HTML tags by beginning with either <% or <jsp:.
JSPs follow XML syntax, they all have a start tag (which includes the element name) and
a matching end tag. Like XML tags, a JSP tag with an empty body can combine the start
and end tags into a single tag. The following is an empty body tag:
<jsp:useBean id=”agency” class=”web.AgencyBean”>
</jsp:useBean>

The following tag is equivalent to the previous example:
<jsp:useBean id=”agency” class=”web.AgencyBean”/>
Optionally, a JSP element may have attributes and a body. You will see examples of all
these types during today’s lesson. See Appendix C, “An Overview of XML,” for more
information on XML and the syntax of XML elements.

JSP Elements
The basic JSP elements are summarised in Table 13.1.
TABLE 13.1 JSP Elements
Element Type JSP Syntax Description
Directives <%@Directive…%> Information used to control the translation of the
JSP text into Java code
Scripting <%    %> Embedded Java code
Actions <jsp:   > JSP-specific tags primarily used to support
JavaBeans
You will learn about scripting elements first and then cover directives and actions later in
today’s lesson.
Scripting Elements
Scripting elements contain the code logic. It is these elements that get translated into a
Java class and compiled. There are three types of scripting elements—declarations,
scriptlets, and expressions. They all start with <% and end with %>.

Declarations
Declarations are used to introduce one or more variable or method declarations, each one
separated by semicolons. A variable must be declared before it is used on a JSP page.
Declarations are differentiated from other scripting elements with a <%! start tag. An
example declaration that defines two variables is as follows:
<%! String color = “blue”; int i = 42; %>

You can have as many declarations as you need. Variables and methods defined in decla-
rations are declared as instance variables outside of any methods in the class.
Expressions
JSP expressions are single statements that are evaluated, and the result is cast into a
string and placed on the HTML page. An expression is introduced with <%= and must
not be terminated with a semi-colon. The following is an expression that will put the
contents of the i element in the items array on the output page.
<%= items[i] %>

JSP expressions can be used as values for attributes in JSP tags. The following example
shows how the i element in the items array can be used as the value for a submit button
on a form:
<INPUT type=submit value=”<%= items[i] %>”>

What is a JSP?

JavaServer Pages

Yesterday, you looked at developing Web applications using Java servlets.
Servlets have the advantage of being able to generate the HTML Web page
dynamically. The disadvantage of servlets is the fact that the developer must
generate a lot of HTML formatting information from within Java. Servlets can
be described as large amounts of boring HTML println() statements inter-
spersed with small amounts of interesting Java code.
Servlets make it difficult to differentiate the presentation layer from the logic
layer of an application. This duality of purpose means that servlets do not allow
the roles of HTML designer and Java programmer to be easily separated.
Writing servlets requires the members of the development team to be either
• Java programmers who must learn HTML and Web design
• Web designers who must learn Java

In practice, there are very few Java programmers who make good Web design-
ers, and fewer Web designers who make good Java programmers.
JavaServer Pages are servlets that are written in HTML. Actually, there is a bit
more to it than that, but the Java code on a JSP is usually either non-existent or
very simple, and can be readily understood by non-Java programmers.In today’s lesson, you will learn
• What a JSP is and how its implementation differs from servlets
• The JSP lifecycle—what you have to do and what the Web server will do for you
• How to deploy a JSP
• How to use JavaBeans to hide Java functionality from the JSP
• How to develop a Web application using JSPs
Today’s work builds directly on the knowledge gained yesterday because many of the
mechanisms used in JSPs are the same as servlets.

What is a JSP?
A JSP is just another servlet, and like HTTP servlets, a JSP is a server-side Web compo-
nent that can be used to generate dynamic Web pages.
The fundamental difference between servlets and JSPs is
• Servlets generate HTML from Java code.
• JSPs embed Java code in static HTML.
To illustrate this difference, Listings 13.1 and 13.2 are the same Web page coded as a
servlet and as a JSP, respectively. Each Web page simply reads a parameter called name
from the HTTP request and creates an HTML page displaying the value of the name
parameter. Listing 13.1 shows the servlet, and Listing 13.2 shows the JSP.

LISTING 13.1 Simple Dynamic Page As a Servlet

1: import java.io.*;
2: import javax.servlet.*;
3: import javax.servlet.http.*;
4:
5: public class Hello extends HttpServlet {
6:
7:     public void doGet(HttpServletRequest req, HttpServletResponse res)
8:                  throws ServletException, IOException {
9:         res.setContentType (“text/html”);              
10:         PrintWriter out = res.getWriter();              
11:         String name = req.getParameter(“name”);
12:         out.println (“<HTML>”);
13:         out.println (“<HEAD><TITLE>Hello</TITLE></HEAD>”);
14:         out.println (“<BODY>”);
15:         out.println (“<H1>Hello “ + name + “</H1>”);
16:         out.println (“</BODY>”);
17:         out.println (“</HTML>”);
18:     }
19: }


1: <HTML>
2:   <HEAD><TITLE>Hello</TITLE></HEAD>
3:   <BODY>
4:     <% String name = request.getParameter(“name”); %>
5:     <H1>Hello <%=name%> </H1>
6:   </BODY>
7: </HTML>

Here you can see that the JSP not only requires far less typing, but a lot of the work is
being done for you. How the JSP achieves the same effect with far less code will soon
become clear.
Separating Roles
With a servlet, the Java programmer was forced to generate the entire HTML. With a
JSP, it is much easier to separate the HTML from the application tasks. With the use of
JavaBeans and JSP tag libraries (covered on Day 14, “JSP Tag Libraries”), this separa-
tion is even more explicit.

Using JSPs, the Web designer can concentrate on the design and development of the
HTML page. When a dynamic element is needed, the developer can use a pre-written
bean or tag library to provide the data. The Java programmer can concentrate on develop-
ing a useful set of beans and tag libraries encapsulating the complex Java required to
retrieve the data from an EJB, a database, or any other data source.
Translation and Execution

JSPs differ from servlets in one other respect. Before execution, a JSP must be converted
into a Java servlet. This done in two stages:
1. The JSP text is translated into Java code.
2. The Java code is compiled into a servlet.
The resulting servlet processes HTTP requests. The translate and compile process is per-
formed once before the first HTTP request can be processed. The JSP lifecycle is cov-
ered in more detail later.

2014年4月14日 星期一

Bean Managed Transaction Demarcation

If an EJB is deployed using bean managed transaction demarcation (here referred to as
BMTD, though this abbreviation isn’t used in the EJB specification itself), the EJB con-
tainer allows the bean to obtain a reference to a javax.transaction.UserTransaction
object using the EJBContext. You can see this in Figure 8.3.

Motivation and Restrictions

An EJB might need to be deployed under BMTD if the conditions on which a transaction
is started depend on some programmatic condition. It could be that one method starts the
transaction and another method completes the transaction.
However, the cases where BMTD is needed are few and far between. Indeed, they are so
rare that the EJB specification limits BMTD to Session beans. Entity beans can only be
deployed with CMTD. This makes sense because Entity beans represent persistent trans-
actional data; the transaction context should be as deterministic as possible.
Moreover, if a stateless Session bean starts a transaction, it must also commit that trans-
action before the method completes. After all, the stateless Session bean will have no
memory of the client that just invoked its method after that method completes, so one
cannot expect that the transaction context is somehow miraculously preserved. If you
write a BMTD stateless Session bean that does not commit its own transaction, the EJB
container will rollback the transaction and throw an exception back to the client
(java.rmi.RemoteException for remote clients, or javax.ejb.EJBException for local).
Indeed, even with stateful Session beans, there is a restriction. Any current transaction in
progress when the BMTD Session bean is called will be suspended by the EJB container,
not propagated to the BMTD bean. It is possible that, from the bean’s perspective, there
is a current transaction, but that would refer to any transaction not committed when a
method on that bean was last called.

Using the Java Transaction API
When a Session bean is deployed under BMTD, there is an implementation choice as to
how it should manage its transactions. If interacting solely with an RDBMS, the Session
bean can manage the transactions directly through the JDBC API. Alternatively, it can
use the Java Transaction API, defined by the classes and interfaces in the javax.trans-
action and the javax.transaction.xa packages. The latter is to be preferred, if only
because transactional access to Java Messaging Service resources (you’ll be learning
more about these tomorrow and the day after) can only be performed through the JTA
API. Equally, servlets can also use the JTA API.

For a Session bean to start a transaction, it should first call the getUserTransaction()
method of its SessionContext. You’ll recall that this was the method that throws an
exception under CMTD, but it is the centerpiece of transaction control under BMTD.
Obtaining a UserTransaction does not mean that a transaction has been started. Rather,
it must be started using the begin() method. The transaction can then be completed
using either the commit() or the rollback() method. The current status can also be
obtained using getStatus(). This returns an int whose meaning is defined by the
constants in the javax.transaction.Status interface. Some of the most common status
values are shown in Table 8.2.

JAVA : Transactions and Persistence

Overview of Transactions

If you’ve used RDBMS before, or completed a Computer Studies course or read any
other J2EE book, you’ve probably read a section like this one already. But read on any-
way, if only to be acquainted with some of the J2EE terminology that is used in this
arena.
A transaction is an atomic unit of work:

• Atomic unit means indivisible—either every step within the transaction completes
or none of them do.

• Work here usually means some modification to data within a persistent data store.
In RDBMS terms, this means one or more INSERT, UPDATE, or DELETEs. However,
strictly speaking, it also applies to reading of data through SELECT statements.
For a persistent data store to support transactions, it must pass the so-called “ACID” test:
• Atomic—The transaction is indivisible; the data store must ensure this is true.

• Consistent—The data store goes from one consistent point to another. Before the
transaction, the data store is consistent; afterwards, it is still consistent.
The age-old example is of transferring money between bank accounts. This will
involve two UPDATEs, one decrementing the balance of account #1 and the other
incrementing the balance of account #2. If only one UPDATE occurs, the transaction
is not atomic, and the data store is no longer in a consistent state.

• Isolation—The data store gives the illusion that the transaction is being performed
in isolation. Enterprise applications have many concurrent users who are all per-
forming transactions at the same time, so behind the scenes, the data store uses tech-
niques, such as locks, to serialize access to the contended data where necessary.

• Durability—If a transaction completes, any changes made to the data as a result of
that transaction must be durable. In other words, if the power were to fail a mil-
lisecond after the transaction has completed, the change must still be there when
power is reconnected.


Many data stores use transaction logs to address this requirement. The transaction
log holds a journal of changes made to the actual data. When the transaction com-
pletes, the log is written to disk, although the actual data need not be.

Many data stores allow transactions to be started explicitly using a syntax such as the
following:
begin transaction t1
where t1 is the (optional) name transaction. Transactions are completed using either
commit (make changes permanent) or rollback (undo all changes made in the transac-
tion, and revert all data back to the state before the transaction began). Many data stores
will use
commit transaction t1
and
rollback transaction t1


In the EJB specification, these two responsibilities are split. In principle, you can think
of the EJB container as acting as the transaction manager, and the persistent data store
acting only as the resource manager. The term transaction coordinator is sometimes used
instead of transaction manager because there could be more than one resource whose
transactions are being coordinated.

Splitting the responsibilities of transaction management and resource management has
two consequences. For the bean provider, it means that to start a transaction, the bean
must interact both with the EJB container and with the persistent data store. The former
interaction is largely implicit because it is configured through the deployment descriptor
(and as you know, the latter interaction is implicit if CMP Entity beans are used). The
other consequence is that, for the persistent data store, it must defer all transaction con-
trol responsibility up to the EJB container. Behind the scenes, there is some quite sophis-
ticated communication going on; you’ll learn a little about this activity later on today.

2014年4月13日 星期日

馬航副機師疑打手機求救

在馬航MH370客機失蹤五個星期仍然下落不明之際,馬來西亞國營《新海峽時報》周六表示調查有新發現,指客機三月八日凌晨從雷達屏幕消失後,副機師法里克趁着客機在檳城附近上空低空飛行時,曾在機上嘗試用手機撥打電話,惟電話通訊突然中斷,可能是因為客機當時以高速遠離地面通訊塔。
  報道引述消息人士稱,MH370失聯後曾經低空飛行,當時它在大馬西岸檳城附近上空的低空飛行高度,足以讓最近的地面通訊塔接收到機上手機訊號。調查人員正在深入調查這一項新發現,冀能完整呈現MH370從雷達消失前一刻,機上發生過的事情。MH370最後從軍方雷達屏幕消失時,位置在檳城西北約三百二十公里。專家表示,通訊塔可接收到從七千呎高度傳來的手機訊號。
  對於法里克的電話通訊突然中斷,消息人士認為原因可能是MH370急速飛離接收到機上手機訊號的通訊塔後,沒有飛入另一處通訊塔所在的訊號覆蓋區。在這篇題為「絕望的求救電話」的頭版報道中,沒提到法里克要打給誰,因為消息人士不肯泄露調查細節。
  不過,《新海峽時報》也引述另一批接近調查的消息人士稱,法里克的手機在MH370起飛前已中斷連綫,在飛機偏離航道轉變方向至消失之間的一段時間內,法里克的手機又重新駁綫,但無法肯定他是否真的有打出電話。所謂「重新駁綫」,未必一定顯示有人打出電話,可能只是飛機上有人再次開啟手機,而地面通訊塔接收到有關手機訊號。
  當局也追查法里克的電話記錄,顯示他最後通話的人是他平日經常聯絡的,那個人的電話號碼在他的撥電記錄中頻繁出現。法里克的一名親戚上周一表示,法里克與母親之間的關係密切,如果他在飛機消失前真的打過電話,可能是聯絡她。
  《新海峽時報》也表示,法里克最後一次以智能手機軟件WhatsApp Messenger通訊,是三月七日深夜十一時半,即MH370起飛之前一小時多,當晚MH370於三月八日零時四十一分從吉隆坡國際機場起飛。
  大馬代理交通部長希山慕丁回應該篇報道表示:「除非我們經過查證,否則無法談論這些報道。」他說:「如果真有其事,我們應早就知道了。」
  調查人員於上月指MH370飛出馬來西亞領空時,不但蓄意改變航道,並以人手關閉機上通訊系統,令警方馬上展開刑事調查。MH370為何失聯仍是一個謎,多方作出的推測「各說各話」,有推測指是劫機或恐襲,甚至有人認為是機師蓄意墜機自殺。

Java EJB introduction

What Is an EJB?

In a typical J2EE application, Enterprise JavaBeans (EJBs) contain the application’s business
logic and live business data. Although it is possible to use standard Java objects to
contain your business logic and business data, using EJBs addresses many of the issues
you would find by using simple Java objects, such as scalability, lifecycle management,
and state management.

Beans, Clients, Containers, and Servers

An EJB is essentially a managed component that is created, controlled, and destroyed by
the J2EE container in which it lives. This control allows the container to control the
number of EJBs currently in existence and the resources they are using, such as memory
and database connections. Each container will maintain a pool of EJB instances that are
ready to be assigned to a client. When a client no longer needs an EJB, the EJB instance
will be returned to the pool and all of its resources will be released. At times of heavy
load, even EJB instances that are still in use by clients will be returned to the pool so
they can service other clients. When the original client makes another request of its EJB,
the container will reconstitute the original EJB instance to service the request. This pooling
and recycling of EJB instances means that a few EJB instances, and the resources
they use, can be shared between many clients. This maximizes the scalability of the EJBbased
application. The EJB lifecycle is discussed further on Days 5 and 6.
The client that uses the EJB instance does not need to know about all of this work by the
container. As far as the client is concerned, it is talking to a remote component that supports
defined business methods. How those methods are implemented and any magic performed
by the container, such as just-in-time instantiation of that specific component
instance, are entirely transparent to the client part of the application.

The EJB benefits from certain services provided by the container, such as automatic
security, automatic transactions, lifecycle management, and so on. To do this, the EJB
must conform to certain rules and implement an appropriate interface that allows the
container to manage the component. The EJB is packaged with configuration information
that indicates the component’s requirements, such as transaction and security requirements.
The container will then use this information to perform authentication and control
transactions on behalf of the component—the component does not have to contain code
to perform such tasks.

The primary purpose of the container is to control and provide services for the EJBs it
contains. When it needs to use some underlying functionality, such as creating a transaction
on behalf of a bean, it uses the facilities of the underlying EJB server. The EJB
server is the base set of services on top of which the container runs. Different types of
EJB will run in different containers, but many different EJB containers can run on a single
EJB server. EJB servers are generally delivered as part of a J2EE-compliant application
server (examples include BEA WebLogic and IBM WebSphere). You will install and
run the application server, which will provide the underlying services required of an EJB
server and will host EJB containers.

The EJB Landscape

As you have seen, the J2EE Blueprints (http://java.sun.com/blueprints/enterprise/
index.html) define a target architecture for a typical J2EE-based application. In
this architecture, EJBs live in the middle tier and are used by other application components
that live in the presentation tier. Although it is possible that both of these logical
tiers will reside on the same computer, it is most likely that they will reside on different
machines. This means that an EJB will usually have to be made available to remote
clients.

To offer services to remote clients, EJBs will export their services as RMI remote
interfaces. RMI allows you to define distributed interfaces in Java. There are certain
caveats on doing this, not only at the implementation level (such as declaring that
RemoteExceptions may be thrown when calling a method on an EJB) but also at the
design level. Designing remote interfaces is a skill in itself, which will be explored as
you progress through topics in this book, such as EJBs and J2EE Patterns.
Because they must use an RMI-based interface to access the functionality of the EJB, the
clients of an EJB must have some programming functionality. This means that they are
typically either “thick” clients that provide a GUI interface or Web-server components
that deliver HTML interfaces to “thin” clients. The different types of client are explored
in more detail shortly.

In the other direction, EJBs themselves will make use of data sources, such as databases
and mainframe systems, to perform the required business logic. Access to such data and
services can be through a JDBC database connection, a J2EE Connector, another EJB, or
a dedicated server or class of some form.

隱私權政策

DoubleClick Cookie

Google 會在夥伴網站 (例如顯示 AdSense 廣告或加入 Google 認證廣告聯播網的網站) 上刊登的廣告中,使用 DoubleClick Cookie。使用者在夥伴網站上查看或按下廣告後,系統可能會在他的瀏覽器中放置一個 Cookie。

隱私權政策

  • 第三方廠商 (包括 Google) 會根據使用者先前在您網站的造訪紀錄,使用 Cookie 來放送廣告。
  • Google 和其夥伴會運用 DoubleClick Cookie,根據使用者在您的網站和/或其他網站上瀏覽的內容,對使用者放送合適的廣告。
  • 使用者可以到廣告設定中,選擇停用按照興趣顯示廣告的 DoubleClick Cookie (或者,您也可以將使用者帶往aboutads.info,在該處選擇停止某個第三方供應商使用 Cookie 按照興趣顯示廣告)。
  • 讓網站訪客知道有第三方供應商和廣告聯播網在您的網站上放送廣告。
  • 提供相關供應商和廣告聯播網的網站連結。
  • 讓使用者知道他們可以前往上述網站,拒絕系統以 Cookie 按照興趣顯示廣告 (如果供應商或廣告聯播網提供這項功能)。或者,您也可以將使用者帶往 aboutads.info,然後在該處選擇停止某些第三方供應商使用 Cookie 按照興趣顯示廣告。

Java: Naming Conventions

Naming Conventions

Each naming service has its own mechanism for supplying a name. Perhaps the most
familiar naming convention is that of DNS, where every machine connected to the
Internet has a unique name and address. Most readers should recognize the following as
a host name used by DNS:

www.samspublishing.com

In contrast, LDAP names are based on the X.500 standard and use distinguished names
that look like the following fictitious example:

cn=Martin Bond, ou=Authors, o=SAMS, c=us

This format will also be familiar to users of Microsoft’s Active Directory service, whose
naming system is also based on X.500 but uses a forward slash to separate the various
name components:

cn=Martin Bond/ou=Authors/o=SAMS/c=us

These last two naming conventions have similarities in that they are both hierarchically
structured with the most specific name occurring first and the most general name (or
context) occurring last.

JNDI provides classes that support creating and manipulating structured names; but most
programmers will use simple strings that JNDI passes on to the underlying service with
minimal interpretation.

Some JNDI Service Providers may use names that are case sensitive, and some service
providers may not, it all depends on the underlying technology and environment. To
maintain portability of your applications, it is always best to avoid names that differ only
by letter case and also ensure that names are always spelled in a consistent manner.


Using JNDI

JNDI is a standard component of JDK 1.3 and is, therefore, also part of J2EE 1.3. JNDI
is also included in J2EE 1.2 and is available as a standard Java extension for JDK 1.2
and earlier.

While developing code, the program’s CLASSPATH must include the location of the JNDI
class libraries. As long as the JAVA_HOME environment variable has been set up, the JNDI
classes will be available to the Java compiler.
Running a JNDI-aware program requires a JNDI service to be running and the classes for
that service to be available to the program. Typically, this requires the CLASSPATH to
include one or more JAR files provided by the JNDI provider or a J2EE server vendor.
For implementation-specific details, see the vendor’s documentation.
By default, running a J2EE server starts a naming service on the same machine. If the
default behavior isn’t required, you must change the J2EE server configuration to use an
existing JNDI server.

Using Sun Microsystems’ J2EE Reference

Implementation

Using JNDI with Sun Microsystems’ J2EE Reference Implementation (RI) is straightforward.
Ensure that
• The J2EE_HOME variable exists
• The CLASSPATH variable includes the j2ee.jar file from the lib directory of the
J2EE home directory

Examples of how to do this both for Windows and for Unix are shown in this section.
J2EE RI for Windows

Under systems running Microsoft Windows NT or 2000, you can set the class path interactively
with the following:

Set CLASSPATH=%J2EE_HOME%\lib\j2ee.jar;%CLASSPATH%
Typically, it is better to set the class path as a system-wide environment variable (via the
My Computer properties dialog). A suitable value is as follows:

.;%J2EE_HOME%\lib\j2ee.jar

The class path can also include additional JAR files and directories for other Java components.
It is important to define the current directory (.) in the class path; otherwise, the Java
compiler and runtime systems will not find the classes for the program being developed.
J2EE RI for Linux and Unix
Under Linux and Unix, set the class path with the following:
CLASSPATH=$J2EE_HOME/lib/j2ee.jar:$CLASSPATH
Starting the JNDI Server
Startup the J2EE RI server, as Day 2, “The J2EE Platform and Roles,” described, and the
JNDI server will start at the same time. You start the J2EE server by entering the following
command from a command-line window:

j2ee –verbose

The J2EE server will run in that window until you close the window down or enter the
following shutdown command from another command-line window:

j2ee -stop

Obtaining an Initial Context

The first step in using the JNDI name service is to get a context in which to add or find
names. The context that represents the entire namespace is called the Initial Context and
is represented by a class called javax.naming.InitialContext and is a sub-class of the
javax.naming.Context class.
A Context object represents a context that you can use to look up objects or add new
objects to the namespace. You can also interrogate the context to get a list of objects
bound to that context.
The javax.naming package contains all the simple JNDI classes. Sub-packages within
the javax.naming package provide additional JNDI functionality, such as directorybased
features like attributes.
The following code creates an initial context using the default JNDI service information:
Context ctx = new InitialContext();
If something goes wrong when creating the initial context, a NamingException is thrown.

Java: Naming and Directory Services

Naming and Directory Services

A Naming Service provides a mechanism for giving names to objects so that you can
retrieve and use those objects without knowing the location of the object. Objects can be
located on any machine accessible from your network, not necessarily the local workstation.
A real-world example is a phone directory. It stores telephone numbers against names
and addresses. To find someone’s phone number is simply a matter of using his or her
name (and possibly address) to identify the entry in the phone book and obtain the stored
phone number. There are a few complications, such as finding the right phone book to
look in, but it is essentially fairly simple.
Incidentally, naming services have a similar problem to that of finding the right phone
book. This is known as obtaining a context. A name can only be found if you examine
the right context (phone book).
A Directory Service also associates names with objects but provides additional information
by associating attributes with the objects.
The yellow pages phone directory is a simple form of a directory service. Here, businesses
often include advertisements with additional information such as a list of products
sold, professional qualifications, affiliated organizations, and even location maps for their
premises. These attributes add value to the name entry. A directory service will normally
provide the ability to find entries that have particular attributes or values for attributes.
This is similar to searching the yellow pages phone book for all plumbers running a 24-
hour emergency service within a certain area.
Yellow page style phone books also store names under different categories—for example,
plumbers or lawyers. Categorizing entries can simplify searching for a particular type of
entry. These categorized entries are a form of sub-context within the directory context of
the local phone book.

Why Use a Naming Service?

Naming Services provide an indispensable mechanism for de-coupling the provider of a
service from the consumer of the service. Naming services allow a supplier of a service
to register their service against a name. Users, or clients, of the service need only know
the name of the service to use it.
Think of the phone book once more, and how difficult it would be to find someone’s
phone number without the phone book. Obtaining your friend’s phone number means
going to their home and asking, or waiting until you meet up with them again—which
may be difficult to organize because you can’t phone them to arrange the meeting
The phone book is a directory service. In fact, a phone book is often referred to as a
phone directory. The phone directory service lets you look up a person or company’s
phone book using their name as a key.
At the end of the day, it is very difficult to imagine a world without naming services.

What is JNDI?

JNDI is a Java API that defines an interface to Naming and Directory Services for Java
programs. JNDI is just an API and not, in itself, a Naming and Directory Service. To use
JNDI, an implementation of a Naming and Directory service must be available. JNDI
provides a service-independent interface to the underlying Service Provider implementation.
Figure 3.1 shows how the JNDI layer interfaces between the Java program and the underlying
naming services. Additional naming services can be plugged into the JNDI layer by
implementing the Service Provider Interface (SPI) for JNDI.


Common Naming Services

Figure 3.1 shows that JNDI supports several well-known naming services, including the
following:

• Domain Name System (DNS) is the Internet naming service for identifying
machines on a network.
• Novell Directory Services (NDS) from Novell provides information about network
services, such as files and printers. NDS is found primarily in environments where
the main networking software is Novell.
• Network Information Service (NIS) from Sun Microsystems provides system-wide
information about machines, files, users, printers, and networks. NIS is primarily
found on Solaris systems, but Linux and some other Unix platforms support it.
• Lightweight Directory Access Protocol (LDAP) is the approved standard for an
Internet naming service. LDAP is a true directory service and supports attributes as
well as names for objects. LDAP is fast becoming the de-facto directory service for
the enterprise.

JNDI also supports some more specialized naming systems. For example, CORBA for
distributed component programming and RMI for distributed Java programming.
Although there is no named service provider for Windows Active Directory, it is supported.
Windows Active Directory supports an LDAP interface, and you can access it via the
JNDI LDAP Service Provider Interface.

2014年4月11日 星期五

《爐石傳說》客戶端版本更新至1.0.0.5170

今天《爐石傳說》客戶端版本更新至1.0.0.5170,這一補丁修復了部分爐石傳說客戶端的錯誤問題,並沒有對遊戲性及平衡進行修改。本週六暴雪即將參展北美大型遊戲展PAX EAST,也許爐石傳說的大規模新內容更新會在當天揭曉。
  錯誤修正
  在全屏模式下,按下Alt + Tab後,《爐石傳說》客戶端不再會停留在屏幕上。
  客戶端不會再反复提醒你賽季快要結束的消息。
  在輸掉競技模式比賽后,返回獎勵鑰匙界面,不會再出現鑰匙升級的動畫效果。
  在使用刺殺之後,該卡牌的聲效不會在效果結束或取消後一直播放。別忘記看看那個隨從是不是真的死了。
  在你擁有100或更多金幣之後,牌店中的購買按鈕現在可以正常點擊了。
  在你打開牌店界面時接受好友的挑戰,不再會使牌店界面始終出現,並遮擋套牌選擇的界面。有時候牌店界面就是這麼粘人。
  在退出好友挑戰對戰後,你可以再次在任何模式下開啟新的遊戲了。
  在好友列表中,你的戰網好友的狀態可以正確顯示了,即使他們是在玩其他暴雪遊戲。
  在使用懺悔後,隨從依然能夠正確地因為公正之劍的效果獲得+1生命值了。
  在任務欄中有三個任務的時候完成任務,不會再立即獲得一個新任務了。
  請注意:以下為國外網站對這一補丁文件的數據挖掘結果,而非官方補丁說明!
  兩個全新的任務/成就被添加入遊戲,其中一個只能通過在iPad進行爐石傳說來獲得,而另外一個看上去像是類似韓國網吧獎勵的每日登陸成就。目前這一成就尚未實裝,更多詳情仍舊未知。
  IGR登陸獎勵
  類型:日常任務
  描述:未知
  獎勵:100金幣
  爐石隨身帶
  類型:一次性任務
  描述:通過在iPad上進行一場遊戲獲得
  獎勵:爐石傳說擴展包X1

2014年4月10日 星期四

「老店風華」 App

美食 App 下載了一堆,大部份參考的都是電視裡各大美食節目、美食雜誌推薦或是美食部落客分享的餐廳資訊,這些吃的都是口碑,因為有電視節目背書或是達人推薦基本上已經可以幫我們避免掉許多踩地雷的機會,不過在巷弄之間,還是有很多隱藏版的美食,其中不乏一些歷史悠久的老店,這老店之所以能開那麼久,一定有其過人之處,這次就我們不吃口碑,改吃老店吧!
要靠自己來尋找這些老店也不容易,除了詢問在地人外,我們也可以透過「老店風華」這個 App 來做個全台老店探訪之旅,開啟 App 就會立即將所在地附近經營超過 30 年以上的老店標示出來,並提供詳細的店家資訊,包含最重要的地址及營業時間,每個店家也都有提供其開業的起始西元年,馬上就能體會到濃厚的歷史感與經驗的傳承。
利用「特色主題」分類,可以依地區、特色或是經營年份來做篩選,方便準備到外地旅遊時,依行程來選擇適合的老店,而除了餐廳、小吃之外,其實「老店風華」也收集像是手工藝、佛具店、茶莊、藥房、紙業、製麵、製香…等各種型態的店家,並不侷限在吃上面,只是美食的資料量比較龐大而已。

2014年4月9日 星期三

暗黑破壞神III 2.0.4版最新的更新說明

《暗黑破壞神3》2.0.4補丁更新列表
暗黑破壞神3》2.0.4補丁正式在美服上線,服務器維護完畢後玩家們即可登錄進行遊戲。本次補丁修復了近期藍貼中玩家們反映的遊戲錯誤問題,同時也針對各職業的資料片發售後遊戲中表現進行了技能調整。每個職業的技能調整前都附加了設計理念可以供大家參考。祝大家遊戲愉快!
《暗黑破壞神III》2.0.4 更新檔- v.2.0.4.23119
原文地址
下列為《暗黑破壞神III》2.0.4版最新的更新說明。
暗黑3 資料片死神之鐮
一般
  • 大幅提高由以下數種物品或技能所召喚寵物的生存能力,包括:
    • 斷空
    • 麥西穆斯
    • 吉德賓
    • 傑桑尼庫
    • 無畏勇者之禱文
    • 先祖召喚
    • 天罰之劍 - 聖軍降臨
  • 所有城鎮中心的涅法雷姆祕境石碑、歐瑞克、以及卡達拉的位置都經過調整,以降低不小心點錯的機率
  • 第一章的鐵匠的物品已經不會擋住玩家了
職業
  • 野蠻人
    • 設計理念
      • 許多消耗怒氣的技能用起來相當過癮,但是​​要生成怒氣時,比起能同時攻擊多個目標的技能,只能攻擊單一目標的技能顯得單調許多。所以我們增強了那些用以生成怒氣的單一目標技能,讓這些技能更有競爭優勢
    • 主動技能
      • 猛擊
        • 基本傷害從170%武器傷害提高至215%武器傷害
        • 技能符文- 痛毆
          • 造成昏迷的機率從30%提高至35%,持續1.5秒
        • 技能符文- 猛襲
          • 額外傷害從80%武器傷害提高至100%武器傷害
      • 狂亂
        • 基本傷害從120%武器傷害提高至155%武器傷害
      • 戰吼
        • 錯誤修正:修正使用戰吼之後,怒氣會在5 秒之內不會衰退的錯誤
      • 擲刃斬
        • 基本傷害從150%武器傷害提高至185%武器傷害
        • 技能符文– 奮力一擲
          • 傷害從210%武器傷害提高至270%武器傷害
        • 技能符文– 飛鎚
          • 造成昏迷的機率從30%提高至40%
  • 聖教軍
    • 設計理念
      • 許多消耗聖怒的聖教軍技能表現不如我們的預期,而天堂之怒 - 天火之光則是過於強大。我們調整了天火之光,同時增強了大部分消耗聖怒的聖教軍技能,以鼓勵玩家探索更強大的技能組合
      • 制裁正義之鎚是攻擊單一目標的聖怒生成技能,而比起能同時攻擊多個目標的聖怒生成技能,他們顯得單調許多。所以我們增強了製裁及正義之鎚,讓它們更有競爭優勢
      • 我們稍微調整了戰馬奔騰,降低這項技能的冷卻時間和持續時間。總體上來說,這會讓這項技能的運作時間略微增加;更重要的是,你可以更常施展這項技能。我們取消了戰馬奔騰移除昏迷效果的能力,讓我們更能凸顯戰馬奔騰作為一項移動技能的本質,並且依舊能利用它來解除一些像是監禁屬性的定身技能。此外,我們依舊想讓戰馬奔騰成為實用的戰鬥技能,所以我們也會強化以 ​​提升傷害為主的技能符文
    • 一般
      • 現在聖教軍從所有來源承受的傷害降低15%
    • 主動技能
      • 阿卡拉特勇士
        • 技能符文- 奮戰不息
          • 修正奮戰不息無法縮短天譴冷卻時間的錯誤
      • 祝福之鎚
        • 技能符文- 怒火之鎚
          • 範圍從5碼提高至8
          • 地面的燃燒傷害從95%武器傷害提高至150%武器傷害
        • 技能符文– 冰凍之鎚
          • 錯誤修正:修正冰凍之鎚無法對敵人造成冰冷效果的錯誤
          • 冰凍之鎚現在不會在爆炸後消失
      • 祝福之盾
        • 基本技能傷害從280%武器傷害提高至340%武器傷害
        • 技能符文- 爆焰之盾
          • 傷害從105%武器傷害提高至270%武器傷害
      • 技能符文- 散射之盾
        • 傷害從50%武器傷害提高至333%武器傷害
          • 已知問題:此符文的提示說明並未顯示這項變更
      • 天堂之拳
        • 閃電轟擊的基本技能傷害從250%武器傷害提高至340%武器傷害
        • 迸射電流的基本技能傷害從210%武器傷害提高至340%武器傷害
        • 技能符文- 聖光雷擊
          • 傷害從14%武器傷害提高至80%武器傷害
          • 迸射電光的索敵範圍從12碼提高至18
        • 技能符文- 雷霆裂隙
          • 在5秒內對周圍敵人造成的傷害從80%武器傷害提高至400%武器傷害
          • 電弧傷害範圍從3碼提高至6
        • 技能符文- 天雷風暴
          • 錯誤修正:修正天雷風暴並未按照預定模式移動的錯誤
      • 天堂之怒
        • 技能符文- 天火之光
          • 傷害從950%武器傷害降低至735%武器傷害
      • 正義之鎚
        • 基本技能傷害從175%武器傷害提高至240%武器傷害
        • 技能符文- 爆裂之鎚
          • 傷害從25%武器傷害提高至30%武器傷害
        • 技能符文- 追擊之鎚
          • 追擊之鎚在施放後會更快地自動尋找目標
          • 傷害從200%武器傷害提高至300%武器傷害
      • 聖軍之陣
        • 基本技能傷害從295%武器傷害提高至380%武器傷害
        • 技能符文- 聖軍弓手
          • 傷害從85%武器傷害提高至160%武器傷害
        • 技能符文- 聖軍衛士
          • 傷害從200%武器傷害提高至285%武器傷害
        • 技能符文- 盾甲衝鋒
          • 傷害從75%武器傷害提高至180%武器傷害
        • 技能符文- 戰馬潰敵
          • 造成昏迷的機率從25%提高至30%
      • 制裁
        • 基本技能傷害從200%武器傷害提高至270%武器傷害
        • 技能符文- 報復
          • 傷害從70%武器傷害提高至94%武器傷害
      • 盾牌猛擊
        • 基本技能傷害從325%武器傷害提高至370%武器傷害
        • 技能符文- 爆裂盾擊
          • 殺死敵人造成的爆炸傷害從550%武器傷害提高至660%武器傷害
        • 技能符文- 重盾撼擊
          • 傷害從550%武器傷害提高至740%武器傷害
          • 來自於盾牌格檔機率的傷害加成從150%提高至500%
      • 戰馬奔騰
        • 基本技能冷卻時間從25秒縮短至16
        • 基本技能持續時間從2秒縮短至1.5
        • 不再解除昏迷效果
        • 技能符文- 馬不停蹄
          • 持續時間從3秒縮短至2
        • 技能符文- 鐵蹄破敵
          • 傷害從475%武器傷害提高至515%武器傷害
        • 技能符文- 火魘戰馬
          • 錯誤修正:修正路徑的燃燒痕跡會在持續時間尚未結束時消失的錯誤
        • 技能符文- 縛敵拖引
          • 傷害從125%武器傷害提高至185%武器傷害
      • 聖光掃擊
        • 基本傷害從400%武器傷害提高至440%武器傷害
    • 被動技能
      • 指揮號令
        • 現在改為縮短戰馬奔騰的冷卻時間25%以及火砲轟炸的冷卻時間35%
  • 狩魔獵人
    • 設計理念
      • 許多消耗憎恨的技能用起來相當過癮,但是​​要生成憎恨時,比起能同時攻擊多個目標的技能,只能攻擊單一目標的技能顯得單調許多。所以我們增強了那些用以生成憎恨的單一目標技能,讓這些技能更有競爭優勢
    • 主動技能
      • 迴避射擊
        • 中央射擊的基本傷害從160%武器傷害提高至200%武器傷害
        • 側邊射擊的基本傷害從80%武器傷害提高至100%武器傷害
        • 技能符文- 掩護射擊
          • 錯誤修正:修正側邊射擊造成的傷害低於技能描述數值的錯誤
          • 側邊射擊造成的傷害從160%武器傷害提高至200%武器傷害
          • 側邊射擊的距離從50%提高至80%,以配合中央射擊的距離
      • 追噬箭
        • 基本傷害從125%武器傷害提高至155%武器傷害
      • 衛哨
        • 技能符文- 守護箭塔
          • 此技能符文所降低的傷害,現在會正確顯示在堅韌屬性上
  • 武僧
    • 設計理念
      • 這次武僧沒有任何變更。武僧現在情況相當良好,但是如同我們一直在觀察遊戲的所有面向,我們也會繼續觀察武僧,並做出適當的改變
  • 巫醫
    • 設計理念
      • 法力低落時,巫醫將無法施展強力技能。巫醫缺乏強力的基礎咒術,導致技能組合都是以長時間維持法力為主。我們強化了一些攻擊單一目標的基礎咒術,讓這些技能更具競爭優勢,好讓巫醫在等待法力恢復時,也能施展具攻擊性的技能
      • 我們對蝕魂進行了部分的變更,除了減少法力消耗,同時也強化了持續傷害(DOT)的技能玩法
    • 主動技能
      • 毒液吹箭
        • 基本技能傷害從155% + 40%武器傷害提高至185% + 40%武器傷害
        • 技能符文- 散射吹箭
          • 每支吹箭造成的傷害從65%武器傷害提高至105%武器傷害
        • 技能符文- 尖脊吹箭
          • 恢復的法力從25點提高至50
        • 技能符文- 烈焰吹箭
          • 在4秒內造成的武器傷害從275%提高至425%
          • 現在烈焰吹箭造成的持續傷害可堆棧
        • 技能符文- 撲面毒蛇
          • 造成昏迷的機率從25%提高至33% - 35%
      • 屍蛛
        • 基本技能傷害從216%武器傷害提高至324%武器傷害
        • 技能符文- 跳躍蜘蛛
          • 傷害從238%武器傷害提高至383%武器傷害
        • 技能符文- 烈火蜘蛛
          • 傷害從259%武器傷害提高至400%武器傷害
      • 火焰炸彈
        • 技能符文- 烈焰火柱
          • 傷害從560%武器傷害提高至880%武器傷害
      • 蝕魂
        • 法力消耗從200點降低至50
        • 基本技能傷害從6秒內造成1465%武器傷害提高至12秒內造成4000%武器傷害
  • 秘術師
    • 設計理念
      • 秘術師的「秘法光球 - 冰箭光球」及「電殛」技能在施展時都會發生錯誤。遺憾的是,修正這些錯誤會削弱這些技能。但我們最終還是修正了這兩個技能,好讓它們能與秘術師的其他技能維持平衡
      • 我們對傳送術進行了部分變更,讓它在許多情​​況下變得更加實用。我們讓傳送術每次施法的傳送距離變得更遠了,而為了配合這項變動,時空蟲洞能夠施放的傳送次數,也跟著降低了。在變更之前,你能夠施放四次,傳送140 碼;在變更之後,你能夠施放3次,傳送150 碼。整體而言,我們強化了傳送術
    • 主動技能
      • 秘法光球
        • 冰箭光球
          • 錯誤修正:修正冰箭光球的冰冷效果持續時間比預期久的錯誤
          • 錯誤修正:修正冰箭光球的額外傷害範圍比預期大的錯誤
      • 電殛
        • 技能符文- 能量湧現
          • 觸發係數從0.25降低至0.166
      • 傳送術
        • 傳送距離從35碼提高至50
        • 技能符文- 時空蟲洞
          • 傳送次數上限從4次降低至3
    • 被動技能
      • 秘法充能
        • 錯誤修正:秘法充能現在會正確地為引導類型的法術提供傷害加成
      • 秘學奇才
        • 錯誤修正:修正使用電殛時,秘學奇才能帶來兩倍秘能收益的錯誤
冒險模式
  • 涅法雷姆石碑現在需要短暫的施法時間才能啟動
  • 涅法雷姆祕境
    • 調整下水道及地下渠道風格的地下城場景,以產生更多隨機的變化
物品製作
  • 製作70級的套裝不再需要無瑕帝國等級的寶石,改由尊爵等級的寶石所取代
  • 製作傳奇物品所需的獨特材料掉落機率已經顯著地提升
    • 此掉落機率與死亡氣息一致
  • 製作61-70級的稀有物品不再需要死亡氣息
  • 錯誤修正:現在製作的傳奇盾牌會依照等級給予正確的格擋值
物品
  • 華麗的箱子現在會掉落更華麗的寶藏了
  • 錯誤修正:傳奇等級的追隨者物品現在不會骰錯主要屬性了
  • 瑪瑟爾現在更容易受到驚嚇、掉落傳奇物品製作材料奪魂者之懼了
  • 錯誤修正:禮讚手套不再給予持續60分鐘的強能聖壇和疾行聖壇增益效果
怪物
  • 擁有靈魂虹吸能力的鬼魂所造成的傷害降低
  • 毒素加持
    • 每個毒液球的持續時間從8 秒縮短至6 秒
    • 每次釋放的毒液球數量從4 個降低至3 個
    • 勇士怪群發動毒素加持的時間點會較為分散
  • 現在需要先完成「殺死瑪瑟爾」的任務,瑪瑟爾的寶物才會掉落
任務
  • 在「瘋狂攀爬者」事件中,玩家要殺死事件中生成的怪物,才能完成此項任務
  • 苦痛I及更高難度的「魂甕」事件會生成額外的怪物
  • 苦痛I及更高難度的「夫人的遺骸」事件會生成額外的怪物
  • 在劇情模式中,唯有當玩家在進行「丞相之墓」的任務之前,殺死裂喉才會掉落寶物並提供經驗值
用戶接口
  • 錯誤修正:修正聊天窗口中游戲對象的優先顯示順序高於聊天鏈接的問題
  • 錯誤修正:修正玩家有時無法點擊聊天窗口底部聊天鏈接的問題