Java Struts Web 初體驗~~~

2017-11-05 / Jim Ou

近期因為負責的案子大多都是Java Web，所以也開始接觸了一些Java 的開源框架，也慢慢對Java有了更進一步的了解，而今天要介紹的就是Java Struts，Java Struts是一種走(MVC)架構的框架，跟之前學習過的Spring MVC在應用以及設定上其實有許多相似的地方，接下來就簡單的介紹一下Struts的Hello Worlds!!以及簡單的表單傳送~~~

開發工具 : Eclipse Java Neon.3 Release (4.6.3)
Struts版本 : 1.3.10
Server : Tomcat 9.0

step 1. 先下載Structs1.3.10 ( https://struts.apache.org/download.cgi )

step 2. 接著我們先從Eclipse新增一個Dynamic Web Project

struts-1

step 3. 把剛才下載好的Struts 1.3.10( \struts-1.3.10-all\struts-1.3.10\lib ) 裡面的jar檔加入參考

在專案folder上面點右，選擇Bulid Path >> Add Library

struts-2

選擇User Libraries點選Next，將( \struts-1.3.10-all\struts-1.3.10\lib ) 裡面的jar檔加入

struts-3

struts-4

step 4. 到剛才下載好的Struts1.3.10，找到 struts-blank-1.3.10.war ( struts-1.3.10\apps ) 將副檔名改成*.zip 並且解壓縮，將裡面的檔案複製到專案的WebContent下面

struts-5

這個是一個空白的範例~可以直接使用~裡面包含了核心設定檔struts-config.xml及web.xml透過這個可以加速我們Web App的開發，這時候我們可以直接用Tomcat執行此專案如果出現下圖所示的畫面代表Struts基本設定已經成功了~

struts-6

step 5. 接下來我們打開web.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" 
    version="2.4">
  <display-name>StructWebDemo</display-name>
  
  <!-- Standard Action Servlet Configuration -->
  <servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <load-on-startup>2</load-on-startup>
 </servlet>


  <!-- Standard Action Servlet Mapping -->
  <servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>


  <!-- The Usual Welcome File List -->
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>

</web-app>

<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee

http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"

version="2.4">

<display-name>StructWebDemo</display-name>

<servlet-name>action</servlet-name>

<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>

<init-param>

<param-name>config</param-name>

<param-value>/WEB-INF/struts-config.xml</param-value>

</init-param>

<load-on-startup>2</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>action</servlet-name>

<url-pattern>*.do</url-pattern>

</servlet-mapping>

<welcome-file-list>

<welcome-file>index.jsp</welcome-file>

</welcome-file-list>

</web-app>

從web.xml中的<servlet>設定我們可以看到幾個重點

負責Controller工作的是ActionServlet，理論上只要是Client Request都會經過ActionServlet來發送
ActionServlet會去讀取struts-config.xml這隻設定檔其中包含了Sturts的一些相關設定
servlet-mapping設定，ActionServlet 會去處理所有來自*.do的Request

這些就是web.xml的幾個較為重要的設定~~~

step 6. 打開struts-config.xml，顧名思義這個檔案就是Struts的核心所在了

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"
          "http://struts.apache.org/dtds/struts-config_1_3.dtd">
<struts-config>

	<action-mappings>
		
		<action path="/Hello" type="com.appx.action.HelloAction">			
		　　　　　<forward name="helloUser" path="/pages/Hello.jsp" />
　　　　　　　　　</action>

	
	</action-mappings>


	<!-- ======================================== Message Resources Definitions -->

	<message-resources parameter="MessageResources" />

	<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
		<set-property property="pathnames"
			value="/org/apache/struts/validator/validator-rules.xml,
               /WEB-INF/validation.xml" />
	</plug-in>

</struts-config>

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE struts-config PUBLIC

"-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"

"http://struts.apache.org/dtds/struts-config_1_3.dtd">

<struts-config>

<action-mappings>

　　　　　　　　　</action>

</action-mappings>

<message-resources parameter="MessageResources" />

<plug-in className="org.apache.struts.validator.ValidatorPlugIn">

<set-property property="pathnames"

value="/org/apache/struts/validator/validator-rules.xml,

/WEB-INF/validation.xml" />

</plug-in>

</struts-config>

在struts-config.xml中，透過 action-mappings 的設定，來達成Client Request與Server的溝通

action-mappings : 設定Request與Server Action的對應關係，path=”Hello” and type=”com.appx.action.HelloAction” 時，當我們的Request是Hello發出時，就會使用HelloAction來處理這個Request，而forward的設定則是HelloAction執行結速後要導向的對象，一個action中可以有多個forward對象，在action中將會去對應forward上的name來尋找並返回對應ActionForward 物件，ActionServlet會根據action傳回的ActionForward來將請求轉發至指定的對象。

form-bean : 設定View(表單)，與對應的Class，當表單被送到Server時會將表單的name，去對應form-bean是否有相同的name，如果有找到相同的name，就會將值注入該form-bean對應的Class

step 7. 由action-mappings 的設定我們可以知道，必須要有一個HelloAction來處理Hello發出的請求，而HelloAction是必須繼承org.apache.struts.action.Action且覆寫execute()

package com.appx.action;


import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

public class HelloAction extends Action{

	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
			HttpServletResponse response) throws Exception {

		request.setAttribute("message", " Hello World !!! ");

		return mapping.findForward("helloUser");
	}
	
}

package com.appx.action;

import java.util.HashMap;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;

import org.apache.struts.action.ActionForm;

import org.apache.struts.action.ActionForward;

import org.apache.struts.action.ActionMapping;

public class HelloAction extends Action{

public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,

HttpServletResponse response) throws Exception {

request.setAttribute("message", " Hello World !!! ");

return mapping.findForward("helloUser");

}

如此一來~只要是Hello發出的請求，就都會交由HelloAction來處理，當我們處理完這個Action要做的事之後，必須呼叫ActionMapping的物件，ActionMapping就會去struts-config.xml尋找是否有這個forward對象，如果有找到，Servlet就使用回傳的ActionForward將Request轉發至指定的對象。

因為我們設定的<forward name=”helloUser” path=”/pages/Hello.jsp” />因此我們在相對應得路徑中加入Hello.jsp的頁面

<%@page contentType="text/html" pageEncoding="UTF-8"
	errorPage="error.jsp"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>${message}</title>
</head>
<body>

	<H1>${message}</H1>
</body>
</html>

<%@page contentType="text/html" pageEncoding="UTF-8"

errorPage="error.jsp"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>${message}</title>

</head>

<body>

<H1>${message}</H1>

</body>

</html>

然後就可以啟動Server，http://localhost:8080/${web.xml的display-name}/Hello.do，就可以看到以下畫面

struts-7

這樣我們就完成了Struts 的HelloWorld!!!

另外Struts中還有一個ActionForm的應用，ActionForm可以把我們的表單以物件來表示，所以當我們在設計物件時必須繼承org.apache.struts.action.ActionForm，並且要提供getter及setter的方法，在ActionForm產生後會去與相對應的物件做比對，如果有相同的參數就會用setter將數值注入其中，以下提供簡單的ActionForm操作例子～～～

step 1. 我們先來建立表的物件 UserForm.java

package com.appx.form;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;

public class UserForm extends ActionForm{

    private String username; 
    private String password;
     
    public void setUsername(String username) { 
        this.username = username; 
    } 
    
    public void setPassword(String password) { 
        this.password = password; 
    } 
    
    public String getUsername() { 
        return username; 
    }
    
    public String getPassword() {
        return password;
    } 
    
    public void reset(ActionMapping mapping,
                      HttpServletRequest request) {
        username = null;
        password = null;
    } 
    
}

package com.appx.form;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts.action.ActionForm;

import org.apache.struts.action.ActionMapping;

public class UserForm extends ActionForm{

private String username;

private String password;

public void setUsername(String username) {

this.username = username;

}

public void setPassword(String password) {

this.password = password;

}

public String getUsername() {

return username;

}

public String getPassword() {

return password;

}

public void reset(ActionMapping mapping,

HttpServletRequest request) {

username = null;

password = null;

}

ps.要記得繼承org.apache.struts.action.ActionForm才會有效果喔~~~

step 2. 在struts-config.xml加入<form-bean>設定表單名稱以及與剛剛建立的UserForm對應，並且在action中加入對應的表單名稱

<form-beans>		
          <form-bean name="userForm" type="com.appx.form.UserForm" />
</form-beans>
<action path="/Login" type="com.appx.action.LoginAction" name="userForm">
          <forward name="helloUser" path="/pages/Hello.jsp" />
	  <forward name="loginUser" path="/pages/LoginForm.jsp" />
</action>

<form-beans>

<form-bean name="userForm" type="com.appx.form.UserForm" />

</form-beans>

</action>

step 3. 接著處理Login的Action LoginAction.java

package com.appx.action;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.springframework.beans.factory.annotation.Autowired;

import com.appx.form.UserForm;
import com.appx.service.UserService;


public class LoginAction extends Action{
	
	private UserService userService = new UserService();
	
	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		
            if( ((UserForm) form).getUsername().equals("test") && ((UserForm) form).getPassword().equals("test")  ){
        	    request.setAttribute("message", "Hi~~" + ((UserForm)form).getUsername());
        	    return mapping.findForward("helloUser");
            }else{
        	    request.setAttribute("message", "帳號或密碼錯誤請重新輸入！！！");
        	    return mapping.findForward("loginUser");        	
            }
		
	}
}

package com.appx.action;

import java.util.HashMap;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;

import org.apache.struts.action.ActionForm;

import org.apache.struts.action.ActionForward;

import org.apache.struts.action.ActionMapping;

import org.springframework.beans.factory.annotation.Autowired;

import com.appx.form.UserForm;

import com.appx.service.UserService;

public class LoginAction extends Action{

private UserService userService = new UserService();

public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,

HttpServletResponse response) throws Exception {

if( ((UserForm) form).getUsername().equals("test") && ((UserForm) form).getPassword().equals("test") ){

request.setAttribute("message", "Hi~~" + ((UserForm)form).getUsername());

return mapping.findForward("helloUser");

}else{

request.setAttribute("message", "帳號或密碼錯誤請重新輸入！！！");

return mapping.findForward("loginUser");

}

經過設定，我們的表單會透過ActionForm傳進來，在這裡我們還需要把ActionForm轉型成UserForm才可以使用UserForm的getter方法，經過簡單的帳號密碼驗證，我們透過forward的方式導向登入成功就導向[helloUser]的頁面，失敗就回到登入頁面並顯示登入敗的訊息~~

step 4. 最後我們要加上登入表單的頁面 LoginForm.jsp

<%@page contentType="text/html" pageEncoding="UTF-8"
	errorPage="error.jsp"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>${message}</title>
</head>
<body>
	<H1>Login</H1>
	<H1>${message}</H1>
	<form name="userForm" action="/StructWebDemo/Login.do" method="post">
		username : <input type="text" name="username" />
		<p>
			password : <input type="password" name="password" />
		<p>
			<input type="submit" />
	</form>
	<a href="/StructWebDemo/pages/AddUser.html">新增使用者</a>
</body>
</html>

<%@page contentType="text/html" pageEncoding="UTF-8"

errorPage="error.jsp"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>${message}</title>

</head>

<body>

<H1>Login</H1>

<H1>${message}</H1>

username : <input type="text" name="username" />

<p>

password : <input type="password" name="password" />

<p>

</form>

<a href="/StructWebDemo/pages/AddUser.html">新增使用者</a>

</body>

</html>

最後我們就可以啟動Server來測是囉~~

struts-8

struts-9

到這邊ActionForm的基本應用也告段落了~~~

最後附上程式連結供大家參考喔~https://github.com/jimmingOu/StrutsWebDemo/

Microsoft Azure Web App 自動調整規模[Auto Scaling]

2017-10-22 / Jim Ou

暨上一篇完成Web App的基本架設後，緊接著要考慮的就是，架設網站通常都需要面臨的問題，就是如果流量超過網站負荷，有沒有好的解決方式？大家應該還記得 Azure VM 可以透過可用性群組的設定來實現負載平衡，想當然爾Web App也有類似的機制去達成這個目的！接下來就與大家分享Auto Scaling的一些簡單設定~~~

step 1 在建立WebApp 選擇方案時記得有選擇有支援自動調整規模的方案

scaling

step 2　在應用程式左邊選單找到相應放大(Scale out)並點選進入，一開始Web App 的AutoScale是Disabled的，所以我們先把AutoScale打開

scaling-1

step 3 點選Add a rule新增一個自動調整的規，然後依照自己的需求選擇計量方式及其增加的規則

scaling-2

需要注意的一點：當我們設定了一個增加規模的規則，相對應的也應該要有一個減少規模的規則，因為一旦增加了規模後，系統並不會自動減少規模，所以我們應該要設定一個減少規模的規則，如此當網站壓力變小後才會把資源釋放出來

scaling-3

除了Default的Auto created scale condition之外我們還可以新增Auto Scale的排程，我們可以點選下方的［ Add a scale condition］，設定要執行Auto Scale的時間區段

scaling-5

最後我們可以從上方的[執行歷程記錄]觀察到scale的增加或減少

Auto Scale 讓我們可以簡單的透過網頁上的設定，達到分流的效果，因此也不需要因為分流而需要管理多台伺服器，所以我們在架設伺服器及管理上也有了更多的彈性及選擇~~

Microsoft Azure 建立 Web App Service 分享~~~

2017-10-10 / Jim Ou

針對雲端的學習與研究也好一陣子了，自從上次使用雲端虛擬器建立了一個Web Service ，最近就在想透過 Azure VM 還是需要自己去管理VM 的設定，備份，負載平衡等……是不是有更快的方式可以讓我們在Azure上面架設一個網站，答案是有的！其實Microsoft Azure還提供另一個服務［Azure App Service for Web］，因此也動手玩了一下這個功能，順便也記錄下來與大家分享～

step 1 首先我們一樣先找到Web App Service這個服務

webApp

step 2 點選Web App，輸入名稱及資源群組後，App Service 的方案系統會自動幫我們帶出預設的(S1)，當然如果我們有不一樣的需求也可以選擇新建一個自己的方案，確定好方案後建可以點選建立Web App Service

webApp1

step 3 到這裡我們就可以在儀表板上面看到剛剛建立的Web App Service，接著我們就準備把程式部屬到App Service上面，在這邊有很多種部屬的方式(Visual Studio,Github,DropBox…..)，我們先用FTP來上傳程式(可以下載FileZilla)，所以我們先下載發行設定檔來取得FTP的帳號密碼

webApp-2

step 4 打開發行設定檔就可以看到FTP的連線相關資訊

publishUrl : 主機名稱
userName : 帳號
userPWD : 密碼

webApp-3

我們把相關資訊輸入至FileZilla並建立連線，然後把程式上傳到wwwroot下面

step 5 程式上傳完成後，我們到應用程式設定 >> 虛擬應用程式和目錄(這裡是設定我們應用程式與網址對應的路徑)

虛擬目錄 : url 路徑
網站根目錄的相對實體路徑 : 應用程式對應url的絕對路徑

webApp-4

設定好之後記得要儲存喔~~~

step 6 接著我們就可以把App Service 的 Url + (剛剛設定的虛擬目錄)，貼到瀏覽器上就可以連上我們的應用程式了

webApp-6

webApp-5

到這裡我們Web App Service 大致上已經完成了

使用 Azure Web App Service 來部屬應用程式與Azure VM 相較之下，確實方便快速許多，如果沒有比較特殊的需求，使用 Azure Web App Service 其實已經很足夠了，但是如果必須對Server有比較進階的一些設定或是需要安裝其他的Framework來驅動應用程式的話，Azure VM 還是比較好的選擇

[Microsoft Azure VM] Web App 如何達成負載平衡(Load Balance)

2017-09-24 / Jim Ou

自從用Microsoft Azure VM建立完Web App之後緊接著就面臨了另一個問題，就是當使用者多到Server負擔的上限時，如何去做到分流達成負載平衡(LoadBalance)，查了一下資料發現，微軟於201603時有更新了虛擬機器的負載平衡功能，也讓負載平衡更容易上手，以下就是簡單的建立負載平衡器的步驟供大家參考～

step 1 在建立負載平衡器之前，我們必需先建立[可用性設定組(Availability set)]，可用性設定組可以將多台VM組成一個群組，負載平衡器則會在這多部虛擬機器之間分配流量

容錯域（Fault Domain） 在可用性集中，容錯域的數量就代表這個可用性集會把虛擬機器分佈在幾個不同的機櫃之中，主要就是避免虛擬機器建立在相同的機櫃中，增加了因為硬體故障就同時發生問題的風險。
更新域（Update Domain） 更新域讓你可以將虛擬機器分成不同的群組，每次新增虛擬機器進可用性集時就會放在另一個更新域。當 Azure 機房在進行系統升級或預定維護作業時，會一次處理一個群組，對使用者而言就是一次只會重啟同一群內的虛擬機器，但順序是不固定的。

azure_lb_0919

step 2 接著我們就可以開始建立Vm ，記得將剛剛建立的Availability set加入新建的Vm中(*Vm建立完成後就不能修改Availability set了喔~)

azure_lb_0919-1

接下來我們可以到儀表板點選剛剛建立的Availability set確認是否有加入剛才建立的VM azure_lb_0919-2

step 3 接著就可以開始建立我們的負載平衡器了(Load Balancer)

這邊我們先選擇public Ip(*待會要透過負載平衡器連入Web的IP)

azure_lb_0919-3

step 4 建立好負載平衡器後，我們到負載平衡器的設定點選[後端集區(backend pools)] 將剛剛建好的Availability set加入，之後我們會透過負載平衡器的公用IP去連結backend pools裡面的VM

azure_lb_0919-4

azure_lb_0919-5

step 5 接著我們點選[探查(Health probes)] ，Health probes主要目的是要用來檢查Vm的健康狀態(伺服器是否正常運作中)，因為是Web網站，所以就先選擇通訊協定Http

path : 探查的路徑( “/” 表示IIS的根目錄，也可在後面加上應用程式的路徑 )
Interval : 負載平衡器會定期探查端點，此為檢查時間的區隔
Unhealthy threshold : 檢查重試次數，到上限如果還是檢查為不健康，則此伺服器會被標記為不健康

azure_lb_0919-6

step 6 最後一個步驟，我們須要建立[負載平衡規則(Load balancing rules)]

Session Persistence : 選擇[Client IP] 會根據用戶端的 IP 位址固定在同一台虛擬機器(有利於Session的運作，但可能會降低負載平衡的彈性)，選擇[Client IP and protocol]則會加上通訊協定來做判斷

到這個步驟基本上我們已經完成了[負載平衡器]的設定

step 7 最後一個步驟，我們就要來驗證，[負載平衡器]的效果，在這裡提供一個簡單的方法，我們可以遠端至VM，將兩台VM的 iisstart.htm 修改為不一樣的內容(*方便區分連到哪一台) azure_lb_0919-10

接著我們先啟動其中一台VM，開啟瀏覽器貼上 http://[負載平衡器] IP 位置，重瀏覽器上可以發現我們連到的是appxWeb01這台VM

azure_lb_0919-9

接著我們啟動令另一台VM，再將第一台VM關閉，一樣在瀏覽器貼上 http://[負載平衡器] IP 位置，我們會發現[負載平衡器]就導向另一台健康的VM，這樣也表示我們已經成功設定好[負載平衡器]了

azure_lb_0919-11

以上就是簡單的建立負載平衡器的步驟供大家參考～更詳細的內容可以去參考官方的文件喔～

參考資料 https://www.azure-vm.recipes/ , https://docs.microsoft.com/zh-tw/azure

Microsoft Azure VM 建立 Windows Web App 分享~~~

2017-09-10 / Jim Ou

　　最近因為工作的關係，需要再Azure上建立一個Web App 因此我需要一個Web Server VM 和Sql Server Vm，所以就開始上網查了一些關資料，經過努力終於建立好一個Web App，以下就是建立Azure Vm的簡單分享~

　　開始前我們需要先有一個帳號登入Azure (https://portal.azure.com) 第一次使用可以有一個月的試用期，並且會贈送6000點的點數，大家可以善用這些點數去熟悉Azure的一些功能，登入後就可以開始建立第一個Azure VM了

ps.申請帳號時需輸入信用卡資訊~~這是必填的~所以就勇敢的給他填下去吧~~

setp 1 建立Web App VM

1.點選[新增]在右邊的視窗直選擇[Windows Server 2016 Datacenter]

azure-1

2.填入*的必填欄位後點選[確定]前往下一個步驟

User name and Password ：就是之後遠端登入VM時的帳號密碼
Resource group：如果沒有群組就新建一個
位置：VM建立的位置，通常選擇離自己近的區域

azure-2

3. 選擇符合自己需求的 VM 機器(~如果將來有需要用到Load balancer需要選有這一個選項的VM)

azure-3

4. 此步驟基本上可以直接按[確定]前往下一步，需要注意的如果有需要用到Load balancer需建立一個Availability set( 要達成負載平衡的vm群組設定 )，如果不需要就可以直接前往下一步

azure-4

5.按下[購買]就會開始建立VM ，建立好之後就可以在儀表板看到剛剛建立的VM

azure-5

6.點選建立好的VM進入VM的詳細資訊頁面，複製Public Ip address使用遠端桌面就可以進入剛剛建好的VM

azure-6

7. VM基本上已經裝好Internet Inforemation Service 所以瀏覽器入 http://localhost 看到以下畫面代表Web Service已經基本的部屬成功，剩下的就是把應用程式加入就可以了

azure-7

8. 接下來測試一下是否可以從外部去連結到VM，因此我們回到自己的本機開啟瀏灠器輸入http://[Vm ip] 正常的話應該要出現跟上圖一樣的畫面，如果是出現以下畫面，大部分的原因是被VM的防火牆擋住了

azure-8

9.為了要可以從外部連接到VM Web Service我們需要加入Http的[輸入規則]讓防火牆可以順利通過，所以我們回到Azure VM 的設定畫面點選該VM下的 Networking加入Http 使用的 80 port ，加入後我們restart VM 再次輸入 http://[Vm ip] 就可以正常顯示IIS的起始畫面了

azure-9

10.如果您的應用程式需要用到 Asp.Net Framework 的話，需要自己在VM上手動安裝喔 ~可以從Service Management 去安裝需要的角色~~

azure-10

step 2 建立Web SQL VM

1.點選[新增]在右邊的視窗直選擇[Windows Server 2016 Datacenter]

azure-11

2.其他的步驟跟建立Web Vm 大同小異，選擇這個方案的原因是VM建起來後就會先幫我們安裝好SQL Server了

3.VM 建立好之後一樣要記得在Azure 該VM的設定頁面中加入MSSQL預設的1433port如此一來才可以從外部連結到

azure-12

4.當我們VM建好後除了可以遠端進去管理DataBase外，也可以經由SQL的角色從本機的 SQL Server Management Studio 遠端連接管理DataBase

以上就是很基本的Azure Web VM and Sql VM 的基本安裝方式，Azure 上還有許多其他很實用的功能，例如load balancer ，Web app(不需建立VM) ，Sql DataBase(不需建立VM) 等，有時間的時候再將有使用過的其他功能Post上來與大家分享~~

這是不是太棒了 ~ 胖達 (Panda)!!!
3B5766BC-0023-465A-ACA5-47631A62A2C7

更多功能的介紹與使用可以參考https://docs.microsoft.com/zh-tw/azure/index官方文件有很詳細的說明喔~~~

[Java 101 基礎篇] Java程式出錯的九種最佳處理方式 ! ( 前篇 )

2017-08-21 / FRank

前言: 通常我們程式執行正常的時候，一切都很美好。但是月有陰晴圓缺，往往都會有意外發生。這篇就是來分享一下遇到意外時，該如何處理 ~

像是下面這張圖，相信大家很常見到 ~ 就是一個常見的情境 ~

在開始進入正題(Exception Handling)之前，先說明一下 Java 跟 Exception 關係 ~

(* Exception 跟 Error 以及 RuntimeException的繼承關係圖)
https://docs.oracle.com/javase/tutorial/figures/essential/exceptions-throwable.gif

程式裏面，如果是遇到 Error/RuntimeException ，這一類的類別被Java歸類成 UnChecked Exception，代表程式人員不用特別寫程式進行處理。(*因為這一類的情形，如果真有發生，我們也來不及救了… 。如果JVM 出現OutMemoryError，我們也只能舉雙手投降了)。

至於像其它常見的，像 IOException，FileNotFoundException 等，
都分類為 Checked Exception，這些都是代表程式出錯時，JVM 會把出錯的資訊包裝成特定型態的物件，方便程式人員可以用程式來挽救出錯的情形，但不致於讓程式整個直接結束( Game Over)。

Java對所謂的 Checked Exception，在語法上有提供了幾個相關的關鍵字，
如 try / catch 以及 throws。接下來，我們先來看用 try / catch的用法 ~

Round 1 : 通常程式需要 I/O, connect Network, 或 Database 時，我們都會加上 try/catch
如下

public void doNotCloseResourceInTry() {
    FileInputStream inputStream = null;
    try {
        File file = new File("./tmp.txt");
        inputStream = new FileInputStream(file); //<span style="color: #ff0000;">如果這行出錯，下面還會執行嗎</span> ??
        inputStream.close(); // 可能會被跳過 !!!
    } catch (FileNotFoundException e) {
        log.error(e);
    } catch (IOException e) {
        log.error(e);
    }

public void doNotCloseResourceInTry() {

FileInputStream inputStream = null;

try {

File file = new File("./tmp.txt");

inputStream = new FileInputStream(file); //<span style="color: #ff0000;">如果這行出錯，下面還會執行嗎</span> ??

inputStream.close(); // 可能會被跳過 !!!

} catch (FileNotFoundException e) {

log.error(e);

} catch (IOException e) {

log.error(e);

}

上面的寫法，相信很容易在各種案子或各個地方看到~
基本上是ok的…javac 編譯也會過…我們稱「有借有還」
就像有 open動作，就該會有 close的動作。

不過，重點不只要寫 close，還要在對的地方寫，寫錯地方就等同於沒寫。
在上面第五行的地方，使用了 new FileInputStream(file) ;
也許各位會想，就是 new FileInputStream的物件，為何會出錯呢 ?!
原因可能會有很多，舉簡單二、三個原因來看，

檔案已經存在。代表無法再產生一個 FileInputStream來存取同一份檔案資源
寫入權限不足，比如說一般user無法寫入系統的資料夾
硬碟空間已滿，這理由也很有可能會發生的喔 ~~~

那出錯之後呢 ?! 程式沒出錯的話，會一路從上往下執行，然後略過 catch。
但是如果一出錯，則程式流程會立即跳出 try { } 的區塊，然後進入 catch 的部份。
以上面來說的話，就是第五行出錯，會直接跳到第七行的 catch ，
而忽略最重要的第六行 close() . (*進而可能會導致記憶體一直浪費，而沒有被回收，也就是所謂的 Memory Leak)

所以，該怎麼做比較對呢 ?!
Round 2 : 加上 finally ，如下面的第九行

public void closeResourceInFinally() {
    FileInputStream inputStream = null;
    try {
        File file = new File("./tmp.txt");
        inputStream = new FileInputStream(file);
        // use the inputStream to read a file
    } catch (FileNotFoundException e) {
        log.error(e);
    } finally {
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
                log.error(e);
            }
        }
    }
}

public void closeResourceInFinally() {

FileInputStream inputStream = null;

try {

File file = new File("./tmp.txt");

inputStream = new FileInputStream(file);

// use the inputStream to read a file

} catch (FileNotFoundException e) {

log.error(e);

} finally {

if (inputStream != null) {

try {

inputStream.close();

} catch (IOException e) {

log.error(e);

}

但是別忘了，即使在第九行之後，如果有呼叫 close() 時，也還是要再加一個 try/catch 才能真正的讓編譯器通過。 (*不然就是考慮 throws 用法，我們稱之謂「轉身逃避」)

但…又有人會說，為何已經用 try / catch 了，而裏面還要再包一層呢 ~~
是不是感覺有點多餘呢 ~?!

沒錯，就是有點多餘… 所以在 JDK 7 出來後，Oracle 原廠有加入個簡化的語法，
稱之為 try-with-resource，
語法:
try ( 欲使用後關閉的物件 ) {
// 正常地使用物件
} catch (相對應的例外) {
// 例外發生時的處理，如 log, rollback 或 send email 等
}

範例如下 :

public void automaticallyCloseResource() {
    File file = new File("./tmp.txt");
    try (FileInputStream inputStream = new FileInputStream(file);) {
        // use the inputStream to read a file
    } catch (FileNotFoundException e) {
        log.error(e);
    } catch (IOException e) {
        log.error(e);
    }
}

public void automaticallyCloseResource() {

File file = new File("./tmp.txt");

try (FileInputStream inputStream = new FileInputStream(file);) {

// use the inputStream to read a file

} catch (FileNotFoundException e) {

log.error(e);

} catch (IOException e) {

log.error(e);

}

不知各位有沒有注意到，

沒有 close()
更沒有巢狀的 try / catch

try-with-resource的語法就是要讓開發人員更簡便的開發程式，
這麼好用的語法有沒有限制呢 ?! 答案是有 !!!!

限制就是 欲使用後關閉的物件必需直接或間接地實作 AutoCloseable ，至於有哪些類別已經實作，請參考下圖

如果使用的物件不符合期待(也就是直接/間接地實作 AutoCloseable) ，
編譯器會”好心的提醒”開發人員…

是不是真的很實用呢 ?!

也許會想問說，如果是用 JDK6 甚至是 JDK5 的話呢 ?! 嗯~~ 沒問題的，就像下面這張~

(* 就別做夢了，趕快昇級 JDK 版本囉 ~ XD

後半部，我們會再接著介紹程式出錯之後， Exception 的建議處理方式 ~

參考資料(Reference) :
https://dzone.com/articles/9-best-practices-to-handle-exceptions-in-java

Spring 註解之 @Autowired

2017-08-21 / Jim Ou

Spring 中的核心思為Ioc 與 DI 而DI 則是去實現 Ioc 的一個方式，而@Autowired就是Spring 2.5 後提供的一種方式，它可以對class成員變量、方法及構造函數進行標註，完成自動裝配的工作

一 . @Autowired可使用的地方

1.class 的 setter 方法上面

public class User(){
  public string name ;

  @Autowired
  public void setName(){...}
  /*
    spring建立User的bean的時候，就會自動尋找匹配的參數注入到該bean當中
  */
}

public class User(){

public string name ;

@Autowired

public void setName(){...}

spring建立User的bean的時候，就會自動尋找匹配的參數注入到該bean當中

}

2.class 的建構函式上

public class User(){
  @Autowired
  public User(){...}
}

public class User(){

@Autowired

public User(){...}

}

3.成員變量上

public class User(){
  @Autowired
  public UserDao userDao ;
  /*
    此作法則可省略UserDao setter 的方法
  */
}

public class User(){

@Autowired

public UserDao userDao ;

此作法則可省略UserDao setter 的方法

}

二. @Autowired的實作範例

首先我們先建立一個 Family.java 及 People.java

public class Family {
	private People people;
 
	public void getPeople() {
		return people
	}
 
	public void setPeople(String people) {
		this.people= people;
	}
}

public class Family {

private People people;

public void getPeople() {

return people

}

public void setPeople(String people) {

this.people= people;

}

public class People {
	private String name;
 
	public void getName() {
		System.out.println(name);
	}
 
	public void setName(String name) {
		this.people= name;
	}
}

public class People {

private String name;

public void getName() {

System.out.println(name);

}

public void setName(String name) {

this.people= name;

}

接著在Spring 的 xml 中加入 People<bean>配置People的value

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

	<context:component-scan base-package="com.springmvc.demo" />
	<bean id="family" class="com.springmvc.demo.Family">		
	</bean>
	<bean id="people" class="com.springmvc.demo.People">
		<property name="name" value="James" />
	</bean>
</beans>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<context:component-scan base-package="com.springmvc.demo" />

</bean>

</bean>

</beans>

接著我們在 Family.java 加上@Autowired

public class Family {
        @Autowired
	private People people;

	public void getPeople() {
		return people;
	}

	public void setPeople(String people) {
		this.people= people;
	}
}
 
public class MyWeb {
        @Autowired
	private  WebApplicationContext context;
	@Autowired
	private Family family;
	public static void main(String[] args) {		 
		 family.getPeople().getName();		 
	}
 
}

public class Family {

@Autowired

private People people;

public void getPeople() {

return people;

}

public void setPeople(String people) {

this.people= people;

}

public class MyWeb {

@Autowired

private WebApplicationContext context;

@Autowired

private Family family;

public static void main(String[] args) {

family.getPeople().getName();

}

如此一來輸出的結果就會是我們在 xml 中配置 People >> name 的值 ( James )

我們只要將想賦予的值定義於xml中，透過@Autowired即可以直接將直注入，而不

須透過程式碼呼叫setter的方法

三. 當被配置的 bean 數量不為1 時，出現BeanCreationException，以下為解決方式

1.當被配置的 bean 數量不為0 時

我們將xml 中的 Family 註解掉，在執行程式時就會出現BeanCreationException

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

	<context:component-scan base-package="com.springmvc.demo" />
	<!--bean id="family" class="com.springmvc.demo.Family"></bean-->
	<bean id="people" class="com.springmvc.demo.People">
		<property name="name" value="James" />
	</bean>
</beans>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<context:component-scan base-package="com.springmvc.demo" />

</bean>

</beans>

所以我們可以在@Autowired加上 (required=false)，意思就是說在注入時Family不是找不到匹配Bean時也不出Exception

public class MyWeb {
        @Autowired(reequired=false)
	private  WebApplicationContext context;
	@Autowired
	private Family family;
	public static void main(String[] args) {		 
		 family.getPeople().getName();		 
	}
 
}

public class MyWeb {

@Autowired(reequired=false)

private WebApplicationContext context;

@Autowired

private Family family;

public static void main(String[] args) {

family.getPeople().getName();

}

2.當被配置的 bean 數量大於1時，在執行程式時也會出現BeanCreationException

我們在xml 中再加入一個Family的bean，在執行程式時也會出現BeanCreationException

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

	<context:component-scan base-package="com.springmvc.demo" />
	<bean id="family" class="com.springmvc.demo.Family"></bean>
        <bean id="family2" class="com.springmvc.demo.Family"></bean>

	<bean id="people" class="com.springmvc.demo.People">
		<property name="name" value="James" />
	</bean>
</beans>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<context:component-scan base-package="com.springmvc.demo" />

</bean>

</beans>

我們配置了兩個Family類型的bean，所以當我們對Family類型注入時，spring無法判斷要用哪一個，我們需要透過@Qualifier指定我們要注入的bean名稱，就可以解決此問題，而@Qualifier亦只能配合@Autowired使用

public class MyWeb {
        @Autowired
　　　　 @Qualifier("family")
	private  WebApplicationContext context;
	@Autowired
	private Family family;
	public static void main(String[] args) {		 
		 family.getPeople().getName();		 
	}
 
}

public class MyWeb {

@Autowired

　　　　 @Qualifier("family")

private WebApplicationContext context;

@Autowired

private Family family;

public static void main(String[] args) {

family.getPeople().getName();

}

如何啟動Jboss

2017-07-21 / Jim Ou

因為工作的關係需要使用到JBoss來啟動網站，過程中也遇到了需多困難

所以就把過程整理一下，做一下筆記

(一) 在Localhost啟動 Jboss

1. 至官網下載 jboss-as-7.1.1.Final　http://www.jboss.org/jbossas/downloads

2. 將檔案解壓縮後，執行 *\\ jboss-as-7.1.1.Final\bin\add-user.bat >> 增加user

未命名3

3. 執行 *\\ jboss-as-7.1.1.Final\bin\standalone.bat >> 執行 jboss

4. 打開瀏覽器 http://localhost:8080 出現以下畫面表示已成功啟動

未命名

5. http://localhost:9990 >> jboss 管理者介面,輸入設定的帳號密碼後的畫面

未命名1

6. “再啟動 standalone.bat” 的情況下將想要deployed的war檔放置 D:\jboss-as- 7.1.1.Final\standalone\deployments 目錄下,即可完成deployed，當資料夾中出現 xxx.wa.deployed 檔案時表示已經成功 deployed

7 . Jboss as 7.1.1 不支援 jdk 1.8.x , 如果環境是 jdk1.8.x的必須安裝 jdk1.7.x

且須設定環境變數 or 使用 Jboss WildFly or Jboss eap

(二) 在Eclipse上加入Jboss

1. Eclipse Help > Eclipse Marketplace… > 搜尋jboss tools 並安裝

2. 安裝完成後新增一個server

未命名4

3.在 Home Directory 設定 Jboss 的資料夾路徑

未命名5-1

4.點選完成後，在下方的server 就會出現Jboss

未命名6-1

6.接著把網站加入至此Serve下即可啟動網站

7.當使用Eclipse 出現了一個錯誤訊息

未命名7

經上網查詢料後發現只要在

D:\jboss-as-7.1.1.Final\standalone\configuration\standalone.xml 中加入

    <profile>
        <subsystem xmlns="urn:jboss:domain:logging:1.1">
            <console-handler name="CONSOLE">
                <level name="INFO"/>
                <filter>
                    <not>
                        <match pattern="JBAS011006"/>
                    </not>
                </filter>
                <formatter>
                    <pattern-formatter pattern="%d{HH:mm:ss,SSS} %-5p [%c] (%t) %s%E%n"/>
                </formatter>
            </console-handler>......

<console-handler name="CONSOLE">

<not>

</not>

</filter>

<pattern-formatter pattern="%d{HH:mm:ss,SSS} %-5p [%c] (%t) %s%E%n"/>

</formatter>

</console-handler>......

即可解決可參考http://www.cnblogs.com/wangjiajun/p/4203373.html 的解說

以上就是啟動JBoss的基本流程～

Spring 註解

2017-07-10 / Jim Ou

Spring 提供了方法來更有效的管理創建物件，使得我們不一定要從程式中去建立物件，配置物件，只需藉由Spring Xml 中 bean 的設定即可達到對物件的管理與配置，如此也使我們的物件可以更有效的被管理

public class HelloWorld {
   ........
}

public class MyService {
   ........
}

public class MyUserDao {
   ........
}

public class MyController {
   ........
}

public class HelloWorld {

........

}

public class MyService {

........

}

public class MyUserDao {

........

}

public class MyController {

........

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
	<bean id="helloWorld " class="com.springmvc.demo.MyUser" />
        <bean id="myService " class="com.springmvc.demo.MyUser" />
        <bean id="myUserDao " class="com.springmvc.demo.MyUser" />
        <bean id="myController " class="com.springmvc.demo.MyUser" />

	
</beans>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd">

</beans>

以上就是透過在xml中加入bean的方式將 class 註冊於Spring中，如此我們就可於xml去管理這個物件，這也就是Spring的核心思想( Ioc ) ，而從Spring 2.0 開始更提供了另一個方法[ 註解 ]去簡化Spring xml 的設定，註解基於Spring 就等同於bean，而 @Service ，@Controller ，@Repository， @Component 就是可以註解在 class 上的四大類，目前來說此四類在Spring 中都是可被註冊為Bean的，

@Component : 是一個泛型的註解，可以被轉換為其他3個類型

@Service : 對應於服務層的註解

@Repository : 對應於數據訪問層(Dao)

@Controller : 對應於控制層 ( mvc 中 action 的應用 )

@Component
public class HelloWorld {
   ........
}

@Service 
public class MyService {
   ........
}

@Repository 
public class MyUserDao {
   ........
}

@Controller 
public class MyController {
   ........
}

@Component

public class HelloWorld {

........

}

@Service

public class MyService {

........

}

@Repository

public class MyUserDao {

........

}

@Controller

public class MyController {

........

}

接著只要我們在 Spring 的 xml 中加入

<context:component-scan base-package="com.springmvc.demo" />

1	<context:component-scan base-package="com.springmvc.demo" />

去啟動自動掃描，所以有加入註釋的 class 就會自動被註冊為 Spring <bean>

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

	<context:component-scan base-package="com.springmvc.demo" />

</beans>

於此Spring就會自動去掃描 com.springmvc.demo 所有的 class 有加入的註解註冊為bean

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/

spring-context-3.0.xsd">

<context:component-scan base-package="com.springmvc.demo" />

</beans>

於此Spring就會自動去掃描 com.springmvc.demo 所有的 class 有加入的註解註冊為bean

如此一來我們的 xml 也就簡化了許多，而註解於bean中的默認名稱為 class名稱(第一個字母小寫)

@Service 
public class MyService {........}

1 2	@Service public class MyService {........}

這個例子來說 bean 的名稱就是 myService 如果想自已定義 bean 的名稱可用@service(“name”)

@Service("helloWorld")
public class MyService {........}

1 2	@Service("helloWorld") public class MyService {........}

如此一來bean的名稱就為 helloWorld，這總方式產生的bean預設是singleton(單一的)，意思就是說容器只會產生這個bean一次，以下列例子來說

@Service("user")
public class MyUser {
	private String name = "yang";

	public void getName() {
		System.out.println(name);
	}

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

public class MyWeb {
        @Autowired
	private  WebApplicationContext context;
	public static void main(String[] args) {
		 
                 MyUser userA = (MyUser) context.getBean("user");
		 userA.setName("wang");
		 userA.getName();
		 
                 MyUser userB = (MyUser) context.getBean("user");
		 userB.getName();
		 
	}

}

@Service("user")

public class MyUser {

private String name = "yang";

public void getName() {

System.out.println(name);

}

public void setName(String name) {

this.name= name;

}

public class MyWeb {

@Autowired

private WebApplicationContext context;

public static void main(String[] args) {

MyUser userA = (MyUser) context.getBean("user");

userA.setName("wang");

userA.getName();

MyUser userB = (MyUser) context.getBean("user");

userB.getName();

}

以上述例子來說結果就會是

wang

因為 user 只會被創建一次，所以 userB 一樣是使用之前被創建的 user，所以取出來的值會是一樣的，但如果我們加入@Scope(“prototype”)

@Service("user")
@Scope("prototype")
public class MyUser {
	private String name;

	public void getName() {
		System.out.println(name);
	}

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

@Service("user")

@Scope("prototype")

public class MyUser {

private String name;

public void getName() {

System.out.println(name);

}

public void setName(String name) {

this.name= name;

}

結果就會是

wang

yang

因為 prototype就是每次取得Bean時，容器會建立一個新的Bean，而不是傳回同一個Bean，所以userB會在創建一個 user 此時 userB 取出來的值就會是 user 的預設值 yang。

總結 : 註解是Spring提供的另一個方式去配置class於容器中，而不需設定在xml中，妥善的使用註解也可使我們的應用程式更為簡潔，當然Spring還提供其他的註解，此篇介紹的是屬於使用於class上面的四類註解，接下來我也將繼續探討其他的註解

何謂 Spring IOC ?

2017-07-04 / Jim Ou

要了解Spring – Ioc前,我想先來說說 Pojo( Plain Ordinary Java Object / Pure Old Java Object)

Pojo可以被歸類為Java的一個對象(Class),但是一個Java Class卻不能說就是Pojo

因為Java Class可以Implement Interface , Extend Parent Class 但是 Pojo 就是一個

乾淨的 Class 可以包含參數及方法卻不能 Implement 及 Extend

Ex :

public class MyUser{

  public int id ;

  public void setId(){ …...  }

  public int getId(){ …...  }

}

public class MyUser{

public int id ;

public void setId(){ …... }

public int getId(){ …... }

}

而在Spring – Ioc中可以管理任何的對象,但一般來說通常都會是Pojo Spring – Ioc 可以說是 Spring 的核心思想可翻譯成控制反轉,但何謂控制反轉,控制甚麼?反轉甚麼?

其實簡單來說就是對Java 對象的控制跟我們一般的認知是相反的,一般來說當我們要建立一個物件的時候都會在應用程式中去 new Object() 並且由應用程式去賦予這個 Object 定義這就是一般的由應用程式去管理,配置所需的物件

Ex:

public class MyPoint {

  public static void main(String[] args)  {

    MyPoint point = new MyPoint();

  }

}

此例子就是透過程式去 new MyPoint() 這個物件

public class MyPoint {

public static void main(String[] args) {

MyPoint point = new MyPoint();

}

此例子就是透過程式去 new MyPoint() 這個物件

而在Ioc中則是相反的,Ioc會提供一個容器去產生這些物件,並且配置及管理這些物件,當應用程式需要甚麼物件時再跟Ioc 容器在提供給((DI))應用程式使用,如此一來物件的依賴關係就變成是應用程式依賴Ioc 容器,應用程式也由主動變成被動的等待Ioc來注入(DI)它所需的資源

xml

<bean id="season" class="com.springmvc.demo.Season">
  <property name="summer" value="summe" />
</bean>

在Spring 的 xml中定義要產生Season這個物,並定義變數summer的值為summer

</bean>

在Spring 的 xml中定義要產生Season這個物,並定義變數summer的值為summer

public class SeasonCount {
  @Autowired
  private Season season;
	
  public Season getSeason() {
    return season;
  }
}

在應用程式中當我們需使用 Season 這個物件時因為他已經被配置於Spring容器中,
所以我們直接使用 @AutoWired 這個註釋 即可把 Season 的值注入

public class SeasonCount {

@Autowired

private Season season;

public Season getSeason() {

return season;

}

在應用程式中當我們需使用 Season 這個物件時因為他已經被配置於Spring容器中,

所以我們直接使用 @AutoWired 這個註釋即可把 Season 的值注入

至於 DI ( Dependecy Injection ) 則是 Ioc 的核心當 Ioc 幫我們創建完對象後在應用程式運行時動態的去注入所依賴的對象

總結:

Spring-Ioc 負責創建管理對象( Pojo ) >> 創建的對象會放在一個容器中

當應用程式需要使用某些對象時由容器提供使用

應用程式的使用對象所需的資源由Ioc注入

應用程式依賴著 Ioc , 並且需要Ioc 提供對象所需的資源

5.Ioc 是一種思想,所以他可以被應用至其他地方並不是局限於Spring

以上是 Spring-Ioc 的基本概觀 , 接下來要探討的就是 Spring 在程式碼中是用甚麼方式去實現Ioc 對物件的創建,配置與管理