Louis@Cathay #Intermediate #Evolution

Spring boot v1.5 (六) spring data jpa 基本操作

2017-07-28T06:48:00.002-07:00

最近天氣好熱，做甚麼事都覺得很懶，想要寫個spring data jpa也是懶懶的，不過這部分卻也是滿重要的一部分，前一篇介紹JDBCTemplate，已經覺得跟以前寫SQL方式有所差異了，JPA帶來的是物件導向的設計面思考，說到JPA不得不提提ORM，Object-relational mapping主要想法為簡化及物件導向的設計，讓RDB更貼近Object，在設計上可以更加便利，甚至透過一些設計可以讓Table具有物件導向的特性如繼承等等，以往要使用ORM的框架，都會先以Hibernate進行，不過近來慢慢地轉向JPA，主要還是在減少程式碼、增加彈性等等，大體的功能沒有差異很大，所以從Hibernate轉到JPA問題不大，JPA要介紹的東西還滿多的，所以我這裡會再分成三個章節來介紹。

SPRING DATA JPA基本操作
JPQL & Named SQL & Native SQL
Cache & DB Design Pattern

SPRING DATA JPA更加簡化的程式撰寫，只需要一個 Interface內寫一些查詢 method就可以操作JPA，因為利用 method 組合查詢條件，確實很方便也很容易理解，若是都沒有辦法符合需求當然也可以自己實作一個來用當然沒有問題。

學習目的：SPRING DATA JPA基本操作。

學習時數：3.5hr

教學影片：

pom.xml 說明

spring-boot-starter-web:配置 Web Project所需的函式庫。
spring-boot-starter-test:配置 unit or mock test 所需的函式庫。
spring-boot-starter-actuator:配置監控spring boot所需的函式庫，後續spring cloud會使用到，所以一開就導入。
spring-boot-starter-jdbc:配置使用jdbc所需的函式庫。
postgresql:配置postgresql連接Driver所需的函式庫。
jasypt-spring-boot-starter:加解密所需的函式庫。
spring-boot-starter-data-jpa:配置Spring data jpa所需的函式庫。
lombok:本次的彩蛋，降低getter與setter的套件。

有使用到上一篇的加解密

程式碼說明

Example6.java

package louisz.springboot.example6;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.PropertySource;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * Louisz Spring boot introduce ex.6
 *
 */

@SpringBootApplication
@PropertySource(name = "EncryptedProperties", value = "classpath:example5.properties")//針對需加解密的設定檔檔名及位置
@EntityScan(basePackages = {"louisz.springboot.example6"})//載入指定package的entity
@EnableJpaRepositories(basePackages = {"louisz.springboot.example6"})//載入指定package jpaRepositories
@EnableTransactionManagement//啟動交易模式
public class Example6 {
 /**
  * 程式執行起點
  * 
  * @param args
  */
 public static void main(String[] args) {
  SpringApplication.run(Example6.class, args);
 }

}

Member.java

package louisz.springboot.example6;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import lombok.Getter;
import lombok.Setter;

@Entity//Entity宣告
@Table(name = "member")//指定對應Table，請記得一定要有ID欄位(名稱可以改變)作為PK喔
public class Member {
 @Id //PK
    @GeneratedValue //之後針對SEQUENCE會需要
    @Setter @Getter //lombok 減少setter及getter method撰寫
    private Long id;
    @Column(nullable = false)//不可為空值
    @Setter @Getter
    private String name;
    @Column(nullable = false)
    @Setter @Getter
    private Integer age;
}

MemberRepository.java

package louisz.springboot.example6;

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

public interface MemberRepository extends JpaRepository{
 /**
  * 使用ID查詢資料，並回傳Member Entity
  * @param id
  * @return
  */
 Member findById(Long id);
 /**
  * 使用ID查詢資料，並回傳Member Entity
  * @param name
  * @return
  */
 Member findByName(String name);
 /**
  * 透過JPQL，使用NAME查詢，並回傳Member Entity
  * @param name
  * @return
  */
    @Query("from Member u where u.name=:name")
    Member findMember(@Param("name") String name);    
    /**
     * 使用NAME及AGE查詢，並回傳Member Entity
     * @param name
     * @param age
     * @return
     */
    Member findByNameAndAge(String name, Integer age);
    /**
     * 使用NAME進行Count，並回傳筆數
     * @param name
     * @return
     */
    Long countByName(String name);
    //不分姓名大小寫的查詢
    /**
     * 使用NAME進行查詢且不分大小寫，並回傳List
     * @param name
     * @return
     */
    List findByNameIgnoreCase(String name); 
}

TestMemberRepository.java

package louisz.springboot.example6;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.test.context.junit4.SpringRunner;

//spring boot 1.4以後的方式
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class TestMemberRepository {

 @Autowired
 private MemberRepository memberRepository;

 @Before
 public void setUp() {
  // 先清除所有資料
  memberRepository.deleteAll();
 }

 @Test
 public void test() throws Exception {
  /*
   * 進行單元測試，先規劃相關情境
   */
  // 先確認是否清除完成
  Assert.assertEquals(0, memberRepository.findAll().size());
  // 新增一筆資料
  Member m = new Member();
  m.setId(1l);
  m.setAge(new Integer(12));
  m.setName("louisz");
  memberRepository.save(m);
  // 確認新增資料筆數
  Assert.assertEquals(1, memberRepository.findAll().size());
  // 檢查新增的資料是否正確
  Assert.assertEquals(12, memberRepository.findByName("louisz").getAge().longValue());
  // 修改姓名
  m.setName("jessie");
  memberRepository.save(m);
  // 檢查新增的資料是否正確
  Assert.assertEquals("jessie", memberRepository.findById(1l).getName());
  // 刪除新增的資料
  memberRepository.delete(memberRepository.findById(1l));
  // 確認刪除資料筆數
  Assert.assertEquals(0, memberRepository.findAll().size());
  // 再度儲存
  memberRepository.save(m);
  // 查詢姓名為jessie的筆數
  Assert.assertEquals(1, memberRepository.countByName("jessie").longValue());
  // 不分大小寫查詢姓名
  Assert.assertEquals(0, memberRepository.countByName("JESSIE").longValue());
  Assert.assertEquals(1, memberRepository.findByNameIgnoreCase("JESSIE").size());
 }

}

單元測試看結果，執行時請加上-Djasypt.encryptor.password=supersecretz
Github code(louisz.springboot.example6)
參考連結：
https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories.query-methods
http://blog.didispace.com/springbootdata2/
https://projectlombok.org/

https://springframework.guru/category/spring/spring-data/

Spring boot v1.5 (五) JDBCTemplate

2017-07-01T02:13:00.004-07:00

我個人是較推崇 JPA的，不過有些情況下，或是架構設計上，會需要純SQL的方式進行，但是像教科書介紹的方式進行，在實務上很難看到，太難用、程式太醜、修改太複雜等等都是要克服的問題，不可能期望所有開發者都是同一高等級的，JDBCTemplate某程度簡化了使用SQL的繁雜度，若是需要大量的純SQL時，JDBCTemplate絕對是首選，也會介紹JDBCTemplate如增刪修查方式、Connection Pool設定及帳密加密的方式等等。

預先準備項目：請先下載並安裝 PostgreSQL，並建立一個DB(louisz)及Table(users)，DDL如下:。

CREATE DATABASE louisz
    WITH 
    OWNER = louisz
    ENCODING = 'UTF8'
    LC_COLLATE = 'Chinese (Traditional)_Taiwan.950'
    LC_CTYPE = 'Chinese (Traditional)_Taiwan.950'
    TABLESPACE = pg_default
    CONNECTION LIMIT = -1;

CREATE TABLE public.users
(
    id integer NOT NULL,
    name character varying COLLATE pg_catalog."default",
    email character varying COLLATE pg_catalog."default",
    mobilenumber character varying COLLATE pg_catalog."default",
    CONSTRAINT user_pkey PRIMARY KEY (id)
)
WITH (
    OIDS = FALSE
)
TABLESPACE pg_default;

學習目的：使用自訂屬性設定檔、屬性一些進階的使用。

學習時數：3.5hr

教學影片：

pom.xml 說明

spring-boot-starter-web:配置 Web Project所需的函式庫。
spring-boot-starter-test:配置 unit or mock test 所需的函式庫。
spring-boot-starter-actuator:配置監控spring boot所需的函式庫，後續spring cloud會使用到，所以一開就導入。
spring-boot-starter-jdbc:配置使用jdbc所需的函式庫。
postgresql:配置postgresql連接Driver所需的函式庫。
jasypt-spring-boot-starter:加解密所需的函式庫。

example5.properties JDBC設定檔說明

#DB設定資訊
#PostgreSQL JDBC URL
spring.datasource.url= jdbc:postgresql://localhost:5432/louisz
#DB使用者帳號
spring.datasource.username=louisz
#DB使用者密碼已經加過密的，請使用自己產生的
spring.datasource.password=ENC(xOSgfOF9jzB8jpYSB1O+4jEobziG16pA)

產生亂碼值的指令

java -cp ~/.m2/repository/org/jasypt/jasypt/1.9.2/jasypt-1.9.2.jar  org.jasypt.intf.cli.JasyptPBEStringEncryptionCLI input="contactspassword" password=supersecretz algorithm=PBEWithMD5AndDES
input:需要加密的資訊
password:壓密KEY，可以自己定義
結果應該像是這樣，OUTPUT就是被加密過後的值

----ENVIRONMENT-----------------

Runtime: Oracle Corporation Java HotSpot(TM) 64-Bit Server VM 24.45-b08



----ARGUMENTS-------------------

algorithm: PBEWithMD5AndDES
input: contactspassword
password: supersecretz



----OUTPUT----------------------

XcBjfjDDjxeyFBoaEPhG14wEzc6Ja+Xx+hNPrJyQT88=

程式碼說明

Example5.java

package louisz.springboot.example5;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.PropertySource;

/**
 * Louisz Spring boot introduce ex.5
 *
 */

@SpringBootApplication
@PropertySource(name = "EncryptedProperties", value = "classpath:example5.properties")//針對需加解密的設定檔檔名及位置
public class Example5 {
 /**
  * 程式執行起點
  * 
  * @param args
  */
 public static void main(String[] args) {
  SpringApplication.run(Example5.class, args);

 }

}

UserService.java

package louisz.springboot.example5;

import java.util.List;

import louisz.springboot.example3.User;

public interface UserService {
 /**
  * 新增一筆User資料
  * 
  * @param User
  */
 void merge(User user);

 /**
  * 刪除傳入相同姓名的資料
  * 
  * @param name
  */
 void deleteByName(String name);

 /**
  * 查詢所有資料，並回傳List物件
  */
 List listAll();

 /**
  * 查詢特定id資料，並回該User Object
  */
 
 User findById(Long id);
 
 /**
  * 删除所有用户
  */
 void deleteAllUsers();

 /**
  * 依據傳入的id，依據傳入的User物件，更新資料表中相同id的資料
  * 
  * @param id
  * @param user
  */
 void updateUser(Long id, User user);
}

UserServiceImpl.java

package louisz.springboot.example5;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

import louisz.springboot.example3.User;

@Service
public class UserServiceImpl implements UserService {

 @Autowired
 private JdbcTemplate jdbcTemplate;

 @Override
 public void merge(User user) {
  jdbcTemplate.update("insert into users(id,name,email,mobilenumber) values(?, ?,?,?)", user.getId(),
    user.getName(), user.getEmail(), user.getMobilenumber());
 }

 @Override
 public void deleteByName(String name) {
  jdbcTemplate.update("delete from users where name = ?", name);
 }

 @Override
 public List listAll() {
  return jdbcTemplate.query("select * from users", new BeanPropertyRowMapper(User.class));
 }

 @Override
 public void deleteAllUsers() {
  jdbcTemplate.update("delete from users ");
 }

 @Override
 public void updateUser(Long id, User user) {
  jdbcTemplate.update("update users set name = ? where id = ?", user.getName(), id);
 }

 @Override
 public User findById(Long id) {
  return (User)jdbcTemplate.queryForObject(
    "select * from users where id = ?", new Object[] { id },
    new BeanPropertyRowMapper(User.class));
 }

}

TestUserServiceImpl.java

package louisz.springboot.example5;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.test.context.junit4.SpringRunner;

import louisz.springboot.example3.User;

//spring boot 1.4以後的方式
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class TestUserServiceImpl {

 @Autowired
 private UserService userSerivce;// 注入UserService
         // interface，實際instance會呼叫UserServiceImpl物件

 @Before
 public void setUp() {
  // 先清除所有資料
  userSerivce.deleteAllUsers();
 }

 @Test
 public void test() throws Exception {
  /*
   * 進行單元測試，先規劃相關情境
   */
  User user1 = new User();
  user1.setId(1l);
  user1.setEmail("louisz6ster@gmail.com");
  user1.setName("user1");
  user1.setMobilenumber("0912345678");

  User user2 = new User();
  user2.setId(2l);
  user2.setEmail("louisz6ster@gmail.com");
  user2.setName("user2");
  user2.setMobilenumber("0912345678");

  User user3 = new User();
  user3.setId(3l);
  user3.setEmail("louisz6ster@gmail.com");
  user3.setName("user3");
  user3.setMobilenumber("0912345678");
  // 新增三個User資料
  userSerivce.merge(user1);
  userSerivce.merge(user2);
  userSerivce.merge(user3);

  // 查詢全部資料筆數是否吻合，確認新增成功
  Assert.assertEquals(3, userSerivce.listAll().size());
  // 刪除資料
  userSerivce.deleteByName("user1");
  userSerivce.deleteByName("user2");
  // 查詢全部資料筆數是否吻合，確認刪除成功
  Assert.assertEquals(1, userSerivce.listAll().size());
  
  //更新User3姓名跟email
  user3.setName("Jessie");
  userSerivce.updateUser(user3.getId(), user3);
  
  //查詢資料表中User3的資料是否更新成功
  User newUser3 = userSerivce.findById(user3.getId());
  Assert.assertEquals(user3.getName(), newUser3.getName());
  
 }

}

單元測試看結果，執行時請加上-Djasypt.encryptor.password=supersecretz
Github code(louisz.springboot.example5)
參考連結：
http://blog.didispace.com/springbootdata1/
https://www.ricston.com/blog/encrypting-properties-in-spring-boot-with-jasypt-spring-boot/
https://github.com/ulisesbocchio/jasypt-spring-boot

Spring boot v1.5 (四) swagger,properties and structing your code

2017-06-29T08:25:00.000-07:00

在上一章有稍微讓大家看一下swagger怎麼跟spring boot無縫接軌，本章就深入一點來介紹swagger，把它定位在 API似乎有點薄弱，當作工具(Tools)我覺得倒很個很好的解釋，它主要提供的工具分別為 swagger core、swagger codegen、swagger editor、swagger ui等，以下是各自的說明：

swagger core：這是swagger的核心，使用Java撰寫出來的。
swagger codegen：可以依據swagger(yaml格式)產生出來的api json或是url，可產生客戶端(client)相對應的程式碼。
swagger editor：透過這個工具可以產生yaml，有點像是Eclipse IDE一樣，撰寫相對應的yaml，透過yaml可以產服務端(server)及客戶端(client)的程式碼，透過這裡可以玩玩看。
swagger ui：將這工具與你的程式結合，如上章的方式，程式啟動後就會自動生成 api 前端頁面提供使用。

調整一下原本的程式碼，增加客製化的功能，並修改原本Ex3Controller、User增加REST註解，你就會發現swagger的好用。

SwaggerConfiguration.java

package louisz.springboot.example3;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

import static springfox.documentation.builders.PathSelectors.regex;

@Configuration
@EnableSwagger2
public class SwaggerConfiguration {
 @Bean
 public Docket usersApi() {
  return new Docket(DocumentationType.SWAGGER_2).select()
    .apis(RequestHandlerSelectors.basePackage("louisz.springboot.example3")).paths(regex("/user.*")).build()
    .apiInfo(metaData());

 }

 private ApiInfo metaData() {
  ApiInfo apiInfo = new ApiInfo("Louisz User RESTful API", "Louisz User RESTful API for blog", "1.0",
    "Terms of service", new Contact("Louisz Cheng", "#", "louisz6ster@gmail.com"),
    "Apache License Version 2.0", "https://www.apache.org/licenses/LICENSE-2.0");
  return apiInfo;
 }
}

Ex3Controller.java

package louisz.springboot.example3;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.BeanUtils;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;

@RestController
@RequestMapping(value = "/user") // 上層路徑配置
@Api(value = "User Function", description = "操作User的RESTful 線上文件說明") // 最上層的說明                 
public class Ex3Controller {
 // 單一儲存庫
 static Map users = Collections.synchronizedMap(new HashMap());

 /**
  * 取得所有User清單
  * 
  * @return
  */
 @ApiOperation(value = "取得所有User清單", response = User.class)
 @ApiResponses(value = { @ApiResponse(code = 200, message = "正常回覆"), @ApiResponse(code = 401, message = "你尚未驗證通過"),
   @ApiResponse(code = 403, message = "你沒有權限可以使用該功能"), @ApiResponse(code = 404, message = "URL錯誤") })
 @RequestMapping(value = "/all", method = RequestMethod.POST)
 public List getUserList() {
  // 取得所有User List
  return new ArrayList(users.values());
 }

 /**
  * 新增User資料，傳入User JSON資料進行新增，成功回傳success
  * 
  * @param user
  * @return
  */
 @ApiOperation(value = "新增一筆User的資料", response = Iterable.class)
 @ApiResponses(value = { @ApiResponse(code = 200, message = "正常回覆"), @ApiResponse(code = 401, message = "你尚未驗證通過"),
   @ApiResponse(code = 403, message = "你沒有權限可以使用該功能"), @ApiResponse(code = 404, message = "URL錯誤") })
 @RequestMapping(value = "/add", method = RequestMethod.POST)
 public String addUser(@ModelAttribute User user) {
  // 傳入Input JSON會自動轉換為User物件
  users.put(user.getId(), user);
  return "add success";
 }

 /**
  * 傳入id進行查詢，回傳User JSON
  * 
  * @param id
  * @return
  */
 @ApiOperation(value = "透過ID查詢User資料", response = User.class)
 @ApiResponses(value = { @ApiResponse(code = 200, message = "正常回覆"), @ApiResponse(code = 401, message = "你尚未驗證通過"),
   @ApiResponse(code = 403, message = "你沒有權限可以使用該功能"), @ApiResponse(code = 404, message = "URL錯誤") })
 @RequestMapping(value = "/find/{id}", method = RequestMethod.POST)
 public User findUser(@PathVariable Long id) {
  // Output User會自動轉換為JSON物件
  return users.get(id);
 }

 /**
  * 傳入id及JSON User進行資料更新
  * 
  * @param id
  * @param user
  * @return
  */
 @ApiOperation(value = "更新特定User資料", response = String.class)
 @ApiResponses(value = { @ApiResponse(code = 200, message = "正常回覆"), @ApiResponse(code = 401, message = "你尚未驗證通過"),
   @ApiResponse(code = 403, message = "你沒有權限可以使用該功能"), @ApiResponse(code = 404, message = "URL錯誤") })
 @RequestMapping(value = "/update/{id}", method = RequestMethod.POST)
 public String updateUser(@PathVariable Long id, @ModelAttribute User user) {
  // 更新User資料
  User u = users.get(id);
  // System.out.println(u.getName()+"=>"+user.getMobileNumber());
  // 使用了BeanUtils
  BeanUtils.copyProperties(user, u);
  users.put(id, u);
  return "update success";
 }

 /**
  * 傳入id進行資料刪除，回傳success
  * 
  * @param id
  * @return
  */
 @ApiOperation(value = "刪除特定User資料", response = String.class)
 @ApiResponses(value = { @ApiResponse(code = 200, message = "正常回覆"), @ApiResponse(code = 401, message = "你尚未驗證通過"),
   @ApiResponse(code = 403, message = "你沒有權限可以使用該功能"), @ApiResponse(code = 404, message = "URL錯誤") })
 @RequestMapping(value = "/remove/{id}", method = RequestMethod.DELETE)
 public String removeUser(@PathVariable Long id) {
  // 刪除user資料
  users.remove(id);
  return "delete success";
 }

}

User.java

package louisz.springboot.example3;

import io.swagger.annotations.ApiModelProperty;

public class User {
 @ApiModelProperty(notes = "ID", required = true)
 private Long id;
 @ApiModelProperty(notes = "使用者姓名", required = true)
 private String name;
 @ApiModelProperty(notes = "使用者emai", required = true)
 private String email;
 @ApiModelProperty(notes = "使用者手機號碼")
 private String mobileNumber;

 public Long getId() {
  return id;
 }

 public void setId(Long id) {
  this.id = id;
 }

 public String getName() {
  return name;
 }

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

 public String getEmail() {
  return email;
 }

 public void setEmail(String email) {
  this.email = email;
 }

 public String getMobileNumber() {
  return mobileNumber;
 }

 public void setMobileNumber(String mobileNumber) {
  this.mobileNumber = mobileNumber;
 }

}

執行並連結到http://localhost:8090/swagger-ui.html，結果如圖

補充完swagger，進入本章的兩個主題，自訂屬性(application.properties)及專案結構定義，之前有提到application.properties(這裡)，spring boot似乎一些主要的設定資訊都是透過這裡，一般來說大部分專案都會使用到自己所需的設定資訊都會放在檔案中，可以透過File或是Apache Common Configuration或是其他方式進行，在spring boot當中已經把這機制放進去了，所以可以將所需的資訊放在application.properties或是resources下的其他自訂檔案中。
在專案的開發中，分類一向都是很難決定的，因為伴隨著越來越多code，系統或專案結構就變得很重要，以下的分類方式提供給大家參考，當然有些情形是依據當下或是特定的規定進行，不過大致上這樣的分類應該可以應付大部分的專案才是，主要以Layer的概念去切割，如view、controller、model等，然後再細分下去如model.entities、model.facade、controller.service、controller.integrate等，當然也有些基本的如commons、utils，參考結構如下：

company(公司名稱).system(系統別).layer.patterns(design pattern)
company.project(專案).layer.functions(功能)
company.commons(通用)
company.utils(工具)
company.system.commons
company.system.utils

學習目的：使用自訂屬性設定檔、屬性一些進階的使用。

學習時數：1.5 hr

教學影片：

ExampleProperties.java

package louisz.springboot.example4;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component // DI之後介紹
@PropertySource("classpath:example4.properties") //設定自訂的設定檔檔名及路徑
@ConfigurationProperties("app") //prefix
public class ExampleProperties {
 //@Value("${app.name}") 也可以採用這種方式，這樣name可以不用相同，但是不建議
 //，因為後續不好維護
 private String name;
 
 private String version;
 
 private String nameversion;
 
 private String stringvalue;
 private int intvalue;
 private long longvalue;
 private int tenvalue;
 private int twentyvalue;
 
 
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String getVersion() {
  return version;
 }
 public void setVersion(String version) {
  this.version = version;
 }
 public String getNameversion() {
  return nameversion;
 }
 public void setNameversion(String nameversion) {
  this.nameversion = nameversion;
 }
 public String getStringvalue() {
  return stringvalue;
 }
 public void setStringvalue(String stringvalue) {
  this.stringvalue = stringvalue;
 }
 public int getIntvalue() {
  return intvalue;
 }
 public void setIntvalue(int intvalue) {
  this.intvalue = intvalue;
 }
 public long getLongvalue() {
  return longvalue;
 }
 public void setLongvalue(long longvalue) {
  this.longvalue = longvalue;
 }
 public int getTenvalue() {
  return tenvalue;
 }
 public void setTenvalue(int tenvalue) {
  this.tenvalue = tenvalue;
 }
 public int getTwentyvalue() {
  return twentyvalue;
 }
 public void setTwentyvalue(int twentyvalue) {
  this.twentyvalue = twentyvalue;
 }

 
}

TestExampleProperties.java

package louisz.springboot.example4;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.test.context.junit4.SpringRunner;


//spring boot 1.4以後的方式
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)
public class TestExampleProperties {
 @Autowired
 private ExampleProperties exampleProperties;//注入
 
 @Test
 public void getHello() throws Exception {
  //驗證是否符合預期
  Assert.assertEquals(exampleProperties.getName(), "example4");
  Assert.assertEquals(exampleProperties.getVersion(), "1");
  Assert.assertEquals(exampleProperties.getNameversion(), "example4_1");
  System.out.println(exampleProperties.getIntvalue());
  System.out.println(exampleProperties.getTwentyvalue());
 }
 
}

Github code(louisz.springboot.example4)

參考連結：
http://blog.didispace.com/springbootproperties/

Spring boot v1.5 (三) magic RESTful and some swagger

2017-06-25T05:23:00.000-07:00

會用Magic來形容Spring boot的RESTful，一方面是微服務的架構，另一方面則是透過Spring boot真得很容易完成，本篇開始也就會一些專案的經驗帶進來。
簡單介紹一下REST(Representational State Transfer)，具象狀態的傳輸，Wiki是這樣說明的，其實它的出現，主要是因為原本的Web Service太過複雜太謹慎了，SOAP跟XML-RPC不容易讓人一下子就了解，在這惟快不破的時代，時間就是金錢，所以REST的出現，讓原本比較難的Web Service變得簡單易懂，而且也容易上手，有些要點可以參這裡都有說明可以看看，對於微服務來說，無狀態很重要，未來架構設計也應該朝向無狀態，不然很難處理日益暴漲的量，符合REST設計風格的Web API稱為RESTful API，這就是我們常說的RESTful，比Web Service多了幾種操作方式，分別為get、post、put、delete、patch及head等(當然還有其他的)，差別在這裡可以參考看看，Web Service有wsdl，那RESTful有嗎？答案就是Swagger，已經可以算是RESTful的標準了，Spring boot整合swagger也是很無縫地喔。

學習目的：建立一個REST的Controller，並包含了單元測試(Mockito)，以及Swagger的設定。

學習時數：2.5 hr

教學影片：

pom.xml 說明

spring-boot-starter-web:配置 Web Project所需的函式庫
spring-boot-starter-test:配置 unit or mock test 所需的函式庫
spring-boot-starter-actuator:配置監控spring boot所需的函式庫

springfox-swagger2:配置swagger 2 api所需的函式庫
springfox-swagger-ui:配置swagger ui所需的函式庫

程式碼說明

Example3.java

package louisz.springboot.example3;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Louisz Spring boot introduce ex.3
 *
 */

@SpringBootApplication
public class Example3 {
 /**
  * 程式執行起點
  * 
  * @param args
  */
 public static void main(String[] args) {
  SpringApplication.run(Example3.class, args);

 }

}

Ex3Controller.java

package louisz.springboot.example3;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.BeanUtils;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(value = "/user") // 上層路徑配置
public class Ex3Controller {
 //單一儲存庫
 static Map users = Collections.synchronizedMap(new HashMap());

 /**
  * 取得所有User清單
  * 
  * @return
  */
 @RequestMapping(value = "/all", method = RequestMethod.POST)
 public List getUserList() {
  // 取得所有User List
  return new ArrayList(users.values());
 }

 /**
  * 新增User資料，傳入User JSON資料進行新增，成功回傳success
  * 
  * @param user
  * @return
  */
 @RequestMapping(value = "/add", method = RequestMethod.POST)
 public String addUser(@ModelAttribute User user) {
  // 傳入Input JSON會自動轉換為User物件
  users.put(user.getId(), user);
  return "add success";
 }

 /**
  * 傳入id進行查詢，回傳User JSON
  * 
  * @param id
  * @return
  */
 @RequestMapping(value = "/find/{id}", method = RequestMethod.POST)
 public User findUser(@PathVariable Long id) {
  // Output User會自動轉換為JSON物件
  return users.get(id);
 }

 /**
  * 傳入id及JSON User進行資料更新
  * 
  * @param id
  * @param user
  * @return
  */
 @RequestMapping(value = "/update/{id}", method = RequestMethod.POST)
 public String updateUser(@PathVariable Long id, @ModelAttribute User user) {
  // 更新User資料
  User u = users.get(id);
//  System.out.println(u.getName()+"=>"+user.getMobileNumber());
  // 使用了BeanUtils
  BeanUtils.copyProperties(user, u);
  users.put(id, u);
  return "update success";
 }

 /**
  * 傳入id進行資料刪除，回傳success
  * 
  * @param id
  * @return
  */
 @RequestMapping(value = "/remove/{id}", method = RequestMethod.DELETE)
 public String removeUser(@PathVariable Long id) {
  //刪除user資料
  users.remove(id);
  return "delete success";
 }

}


}

User.java

package louisz.springboot.example3;

public class User {
 private Long id;
 private String name;
 private String email;
 private String mobileNumber;
 public Long getId() {
  return id;
 }
 public void setId(Long id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String getEmail() {
  return email;
 }
 public void setEmail(String email) {
  this.email = email;
 }
 public String getMobileNumber() {
  return mobileNumber;
 }
 public void setMobileNumber(String mobileNumber) {
  this.mobileNumber = mobileNumber;
 }

}

SwaggerConfiguration.java

package louisz.springboot.example3;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

import static springfox.documentation.builders.PathSelectors.regex;

@Configuration
@EnableSwagger2
public class SwaggerConfiguration {
 @Bean
 public Docket usersApi() {
  return new Docket(DocumentationType.SWAGGER_2).select()
    .apis(RequestHandlerSelectors.basePackage("louisz.springboot.example3")).paths(regex("/user.*"))
    .build();

 }
}

TestEx3Controller.java(單元測試，請注意註解部分說明)

package louisz.springboot.example3;

//這邊要注意import的方式採用static
import static org.hamcrest.Matchers.equalTo;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.RequestBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;

//spring boot 1.4以後的方式
@RunWith(SpringRunner.class)
@WebMvcTest(Ex3Controller.class)
public class TestEx3Controller {
 @Autowired
 private MockMvc mvc;

 /**
  * 單元測試測試前前置設定
  * 
  * @throws Exception
  */
 @Before
 public void setUp() throws Exception {
  mvc = MockMvcBuilders.standaloneSetup(new Ex3Controller()).build();
 }

 /**
  * 測試範例三的RestController各項method
  * 
  * @throws Exception
  */
 @Test
 public void testEx3Controller() throws Exception {
  /*
   * 撰寫單元測試的時候，先想清楚要測試的流程，例如本範例為測試新增修改刪除功能，
   * 你可以一個一個method測試，你也可以使用先新增一筆，然後進行修改，再查詢後刪 除等，把單元測試想做一個情境會比較好進行撰寫。
   */

  RequestBuilder request = null;
  // 我這裡設定使用post進行查詢
  // 1.測試是否回覆200的訊息，並且確認是否尚無資料
  request = post("/users/all/");
  mvc.perform(request).andExpect(status().isOk()).andExpect(content().string(equalTo("[]")));
  // 2.新增一筆資料，新增成功後須回覆success的資訊
  request = post("/users/add/").param("id", "1").param("name", "Louisz").param("email", "louisz6ster@gmail.com")
    .param("mobileNumber", "0912345678");
  mvc.perform(request).andExpect(content().string(equalTo("success")));
  // 3.再進行查詢，因為只有一筆不用特別指定，確認回覆的資訊是否與預期相同
  request = post("/users/all/");
  mvc.perform(request).andExpect(status().isOk()).andExpect(content().string(equalTo(
    "[{\"id\":1,\"name\":\"Louisz\",\"email\":\"louisz6ster@gmail.com\",\"mobileNumber\":\"0912345678\"}]")));
  // 4.修改原有資訊資料，修改成功後須回覆success的資訊
  request = post("/users/update/1").param("name", "Jessie").param("email", "louisz6ster@gmail.com")
    .param("mobileNumber", "0923456789");
  mvc.perform(request).andExpect(content().string(equalTo("success")));
  // 5.使用指定查詢進行該資料比對，確認修改的資訊是否正確
  request = post("/users/find/1");
  mvc.perform(request).andExpect(content().string(equalTo(
    "{\"id\":1,\"name\":\"Jessie\",\"email\":\"louisz6ster@gmail.com\",\"mobileNumber\":\"0923456789\"}")));

  // 6.刪除指定的資料，刪除成功後須回覆success
  request = delete("/users/remove/1");
  mvc.perform(request).andExpect(content().string(equalTo("success")));

  // 7.最後再查詢一次全部資料，須回覆空值，表示單元測試完成
  request = post("/users/all/");
  mvc.perform(request).andExpect(status().isOk()).andExpect(content().string(equalTo("[]")));
 }
}

先進行單元測試，然後執行程式使用 POSTMAN 測試
測試網址
http://localhost:8090/user
Swagger-ui網址
http://localhost:8090/swagger-ui.html
Swagger-api網址
http://localhost:8090/v2/api-docs

Github code(louisz.springboot.example3)

swagger待續....

參考連結：
https://springframework.guru/spring-boot-restful-api-documentation-with-swagger-2/
http://blog.didispace.com/springbootswagger2/

https://zh.wikipedia.org/wiki/REST
https://data-sci.info/2015/10/24/%E5%B8%B8%E8%A6%8B%E7%9A%84http-method%E7%9A%84%E4%B8%8D%E5%90%8C%E6%80%A7%E8%B3%AA%E5%88%86%E6%9E%90%EF%BC%9Agetpost%E5%92%8C%E5%85%B6%E4%BB%964%E7%A8%AEmethod%E7%9A%84%E5%B7%AE%E5%88%A5/

Spring boot v1.5 (二) logging

2017-06-20T07:48:00.000-07:00

本篇主要介紹Logging的機制，Spring boot預設為logback framework，在開始之前先給大家熱身一下，每次執行Spring boot程式在Console上都會看到Spring的Banner如下

這Banner可以自訂喔，可以在google輸入ascii generator關鍵字，就可以找到很多產生這Banner文件，我使用的是這個，然後在/src/main/resources目錄中增加一個banner.txt檔案，然後把產生出來的Code複製到banner.txt的檔案上，也可以透過簡單的設定加上一些顏色
banner.txt

${AnsiColor.BRIGHT_BLUE}


 _        _______          _________ _______  _______ 
( \      (  ___  )|\     /|\__   __/(  ____ \/ ___   )
| (      | (   ) || )   ( |   ) (   | (    \/\/   )  |
| |      | |   | || |   | |   | |   | (_____     /   )
| |      | |   | || |   | |   | |   (_____  )   /   / 
| |      | |   | || |   | |   | |         ) |  /   /  
| (____/\| (___) || (___) |___) (___/\____) | /   (_/\
(_______/(_______)(_______)\_______/\_______)(_______/
                                                      
${AnsiColor.BRIGHT_GREEN}
Application Version: ${application.version}${application.formatted-version}
Spring Boot Version: ${spring-boot.version}${spring-boot.formatted-version}

有點跑掉不過執行結果如下：

這個banner.txt後續也會有一些實質的幫助喔。

Logging在程式開發中是一個基本、必要且非常重要的一項工作，先跟大家說明之後相關範例說明都有 log 可以查看相當方便，也可以習慣這樣的方式，不要甚麼都是System.out，在一個專案或是系統建置成功與否，logging機制相當重要，然後上線後的維運、遇到問題更是仰賴的根本，只要能知道原因就能解決，想要知道原因就一定要很清楚logging的處理方式。

學習目的：使用logback進行log。

學習時數：1.5 hr

教學影片：

pom.xml 說明(logback為預設值，不用額外設定，同Spring boot v1.5(一))

spring-boot-starter-web:配置 Web Project所需的函式庫
spring-boot-starter-test:配置 unit or mock test 所需的函式庫
spring-boot-starter-actuator:配置監控spring boot所需的函式庫，後續spring cloud會使用到，所以一開就導入

application.properties說明

#應用程式名稱
spring.application.name=Louisz Spring boot

#程式啟動 listener port or server.port = 0 自動
server.port = 8090

#選擇需要紀錄的package
logging.level.org.springframework.web=DEBUG
logging.level.louisz.springboot.example2=DEBUG

#將log記錄到指定的檔案中
logging.file=louisz.log

#顯示可以有色彩的屬性
spring.output.ansi.enabled= always

#建議使用logback設定檔案
logging.config=src/main/resources/logback-spring.xml

在 /src/main/resources/ 下增加 logback-spring.xml設定檔，簡易內容如下：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 使用預設值得base.xml -->
    <include resource="org/springframework/boot/logging/logback/base.xml"/>
    <!-- 選擇要記錄的package，並設定只要大於等於debug等級，就記錄下來 -->
    <logger name="org.springframework.web" level="DEBUG"/>
</configuration>

run example2

測試以下幾個網址，是否有log下來相關資訊
http://localhost:8090/log_debug
http://localhost:8090/log_info

進階版的 logback 設定


<!-- <configuration>
    使用logback的基本設定
    <include resource="org/springframework/boot/logging/logback/base.xml"/>
    指定特定目錄進行log，等級設為WARN，分別記錄在Console及檔案 
    <logger name="louisz.springboot.example1" level="WARN" additivity="false">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </logger>
    指定特定目錄進行log，等級設為DEBUG，分別記錄在Console及檔案 
    <logger name="louisz.springboot.example2" level="DEBUG" additivity="true">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </logger>
 </configuration> -->
 <!-- 全部進行Debug level紀錄，並且每30秒監控設定檔是否有異動 -->
<configuration debug="true" scan="true" scanPeriod="30 seconds">
     <!-- 記錄檔存放路徑 -->
    <property name="LOG_PATH" value="logs" />
    <!-- 歷史記錄檔存放路徑 -->
    <property name="LOG_ARCHIVE" value="${LOG_PATH}/archive" />
    <!-- 檔名規則 -->
    <timestamp key="timestamp-by-second" datePattern="yyyyMMdd'T'HHmmss"/>
    <appender name="Console-Appender" class="ch.qos.logback.core.ConsoleAppender">
        <layout>
            <!-- 紀錄存放格式 -->
            <pattern>%d %-5level [%thread] %logger{0} : %msg%n</pattern>
        </layout>
    </appender>
    <!-- 歷史記錄檔搬移規則及存放路徑 -->
    <appender name="File-Appender" class="ch.qos.logback.core.FileAppender">
        <file>${LOG_PATH}/logfile-${timestamp-by-second}.log</file>
        <encoder>
            <pattern>%d %-5level [%thread] %logger{0} : %msg%n</pattern>
            <!-- 套用格式規則置頂 -->
            <outputPatternAsHeader>true</outputPatternAsHeader>
        </encoder>
    </appender>
    <!-- 記錄檔異動規則 -->
    <appender name="RollingFile-Appender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_PATH}/rollingfile.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_ARCHIVE}/rollingfile.log%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
            <totalSizeCap>1KB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>%d %-5level [%thread] %logger{0} : %msg%n</pattern>
        </encoder>
    </appender>
    <!-- 非同步方式進行紀錄 -->
    <appender name="Async-Appender" class="ch.qos.logback.classic.AsyncAppender">
        <!-- 套用至RollingFile-Appender -->
        <appender-ref ref="RollingFile-Appender" />
    </appender>
  <!-- 紀錄套用package、level等 -->
    <logger name="louisz.springboot.example2"  level="debug" additivity="false">
        <appender-ref ref="Console-Appender" />
        <appender-ref ref="File-Appender" />
        <appender-ref ref="Async-Appender" />
    </logger>
    <root>
        <appender-ref ref="Console-Appender" />
    </root>
</configuration>

程式碼說明

Example2.java

package louisz.springboot.example2;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Louisz Spring boot introduce ex.2
 *
 */

@SpringBootApplication
public class Example2 {
 /**
  * 程式執行起點
  * 
  * @param args
  */
 public static void main(String[] args) {
  SpringApplication.run(Example2.class, args);

 }

}

Ex2Controller.java

package louisz.springboot.example2;

//採用的是slf4j外框
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Ex2Controller {
 //請注意不要用static，才能使用this.getClass
  private final Logger logger = LoggerFactory.getLogger(this.getClass()); 
 
  //log level 設定為debug
 @RequestMapping("/log_debug")
    public String debug() {
  logger.debug("This is debug msg.");  
        return "debug level";
    } 
  //log level 設定為info
 @RequestMapping("/log_info")
    public String info() {
  logger.info("This is info msg.");  
        return "info level";
    } 
  //log level 設定為error
 @RequestMapping("/log_error")
    public String error() {
  logger.debug("This is error msg.");  
        return "error level";
    } 
 
}

Github code(louisz.springboot.example2)

參考連結：
https://springframework.guru/using-logback-spring-boot/
https://springframework.guru/logback-configuration-using-xml/
http://blog.didispace.com/spring-boot-banner/

Spring boot v1.5 (一) introduce

2017-06-16T09:23:00.001-07:00

在微服務(microservice)當道的時代，快速已經成為王道的代名詞，然而實現他概念的架構不得不提到Spring boot和Spring Cloud，當然還有DevOps、Container(Moby(Docker))等等(本系列會帶到這些觀念，但是會另外在其他章節來說明，我認為的微服務是怎樣的東西)，所以本系列看標題也可以知道都是Spring boot的介紹跟我遇到的一些問題及想法，希望看的人可以快速進入Spring boot，開發真的不難，難的是改變。

本系列文章大致分為

介紹說明本次學習目的及學習預計完成時間

說明學習目的
預計完成時數
影片

程式碼及設定檔相關分析說明

pom.xml說明
.properties or yml設定檔說明
程式碼說明

其他

遭遇到的問題
參考連結
Code Example Github連結

學習目的：快速完成一隻Spring boot程式，並加入改 listener port及監控機制。

學習時數：1.5 hr

教學影片：

pom.xml 說明

spring-boot-starter-web:配置 Web Project所需的函式庫
spring-boot-starter-test:配置 unit or mock test 所需的函式庫
spring-boot-starter-actuator:配置監控spring boot所需的函式庫，後續spring cloud會使用到，所以一開就導入

程式碼說明

Example1.java

package louisz.springboot.introduce;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Louisz Spring boot introduce ex.1
 *
 */

@SpringBootApplication
public class Example1 {
 /**
  * 程式執行起點
  * 
  * @param args
  */
 public static void main(String[] args) {
  SpringApplication.run(Example1.class, args);

 }

}

Ex1Controller.java

package louisz.springboot.introduce;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * Louisz Spring boot introduce ex.1
 *
 */

@SpringBootApplication
public class Example1 {
 /**
  * 程式執行起點
  * 
  * @param args
  */
 public static void main(String[] args) {
  SpringApplication.run(Example1.class, args);

 }

}

執行時請加上-Dserver.port=8090，就可以啟動時選擇要Listener Port

測試以下幾個網址是否正常
http://localhost:8090/
http://localhost:8090/health
http://localhost:8090/info

Github code(louisz.springboot.example1)

其他：MockTest
TestEx1Controller.java

package louisz.springboot.introduce;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;

import static org.hamcrest.Matchers.equalTo;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@RunWith(SpringRunner.class)
@WebMvcTest(Ex1Controller.class)
public class TestEx1Controller {
 @Autowired
    private MockMvc mvc;
 
    @MockBean
    private Ex1Controller service;
    
    @Before
    public void setUp() throws Exception{
     mvc = MockMvcBuilders.standaloneSetup(new Ex1Controller()).build();
    }
    
    @Test
    public void testHello() throws Exception{
     mvc.perform(MockMvcRequestBuilders.get("/").accept(MediaType.APPLICATION_JSON))
 .andExpect(status().isOk())
 .andExpect(content().string(equalTo("This is Louisz Spring Boot!!")));
    }
    
}

Cordova遇見Genymotion(一)：起手式

2014-06-01T04:46:00.001-07:00

隨著行動裝置的盛行，行動裝置的開發越來越重要了，大致上可分為Native、Web及Hybird的方式開發，而每種方式都有它的優缺點，Native及Web我就不多說了，大家可以上網查一下，今天我要介紹的是Cordova前身是Phonegap，Hybird的方式，混合了Native及Web的優點，但是可能現在還算是起步中，仍有些地方不足以讓大家使用，不過我想中庸之道始終會是王道。

另外就是我使用的模擬器不是用Android的，而是用Genymotion，用意則是效能及速度，而且也滿簡單的說。

接下來會有幾篇都是介紹Cordova的文章，這次先介紹環境的安裝及設定。

安裝Cordova，可以參考這裡，以下步驟為我安裝的部分可以參考一下囉。

下載node.js並安裝，安裝完後可以執行npm --version確認安裝是否成功及版本

下載並安裝cordova，執行npm install -g cordova，確認是否安裝成功及版本可下cordova --version。

下載Genymotion，並安裝Genymotion，安裝完畢後需要進行Virtual Device下載，現在需要帳號登入才可以選擇裝置，所以申請Genymotion帳號及密碼後，就可以下載你所需的Virtual Device。

我這裡是用Netbeans進行開發，所以先下載Netbeans 8，並安裝Netbeans。安裝完後啟動Netbeans。接下來因為要設定Android SDK，所以先下載Android SDK，並安裝後，在Netbeans中設定Android SDK位置。

進行所有安裝測試囉，先開啟一個新的Cordova專案。

不需要做任何事情，直接編譯專案成功後，先啟動Genymotion的Virtual Device，透過以下指令，把編譯出來的APK安裝上去，有出現會後一個畫面就是表示成功囉。

Genymotion\tools\adb install -r xxx.apk
※若是遇到device not found可以試試，adb connect xxx.xxx.xxx.xxx(可以看看模擬器左上角的IP)，在執行安裝指令。

)

Lucene(一)：Lucene4.3.1、Tika、IKAnalyzer中文分詞

2013-07-06T22:36:00.000-07:00

Lucene是一個很強大的搜尋引擎(Lucene wiki)，重點是Open Source，還有很多子專案很好用喔，這次來介紹一下Tika這個子專案，它是一個文件擷取內容及文件metadata的函式庫，支援的檔案格式可以參考一下這裡，加上Lucene Core及中文IKAnalyzer就可以組合文件的中文全文檢索喔。

先下載
Lucene 4.3.1
Tika
IKAnalyzer

Lucene 4.3.1

下載後解壓縮，分別複製以下的jar

lucene-queryparser-4.3.1.jar
lucene-queries-4.3.1.jar
lucene-core-4.3.1.jar
lucene-analyzers-common-4.3.1.jar

Tika 1.4

請下載Source檔案，另外請在下載maven，因為Tika建議重新編譯一份出來，編譯方式參這裡，分別複製以下的jar

tika-xmp-1.4.jar
tika-server-1.4.jar
tika-parsers-1.4.jar
tika-core-1.4.jar
tika-bundle-1.4.jar
tika-app-1.4.jar
original-tika-app-1.4.jar

IKAnalyzer

下載後解壓縮，複製以下的jar

IKAnalyzer2012FF_ul.jar

TvDocumentVo.java：儲存 Tika解析文件內容vo。

public class TvDocumentVo {

private Metadata metadata;

private String content;

public Metadata getMetadata() {

return metadata;

}

public void setMetadata(Metadata metadata) {

this.metadata = metadata;

}

public String getContent() {

return content;

}

public void setContent(String content) {

this.content = content;

}

}

TvDocmentExtract.jar：使用Tika將解析出來的文件內容轉成List。P.S這裡需要調整當檔案數量及大小過大時。

public class TvDocmentExtract {

public List parseAllFilesInDirectory(File directory) throws IOException, SAXException, TikaException {

List result = new ArrayList();

for (File file : directory.listFiles()) {

if (file.isDirectory()) {

parseAllFilesInDirectory(file);

} else {

Parser parser = new AutoDetectParser();

Metadata metadata = new Metadata();

ParseContext parseContext = new ParseContext();

ContentHandler handler = new BodyContentHandler(100*100*1024);//若是檔案過大可以放大這裡的參數

parser.parse(new FileInputStream(file), handler, metadata, parseContext);

TvDocumentVo vo = new TvDocumentVo();

metadata.set("filename",file.getAbsolutePath());//增加檔案絕對路徑屬性

vo.setMetadata(metadata);

vo.setContent(handler.toString());

result.add(vo);

}

}

return result;

}

}

TvIndexManagement.java：建立索引

public class TvIndexManagement {



public static void main(String[] arg) throws ParseException, IOException{

TvIndexManagement tim = new TvIndexManagement();

tim.createIndex("D:\\index", "D:\\document");//參數一為建立索引目錄，參數二為要進行文件擷取目錄

}



public void createIndex(String indexDir,String filesPath){

this.ikanalyzerIndex(indexDir, filesPath);

}

public RAMDirectory readfsIndexToRam(String indexDir) throws IOException{

Directory fsDir = FSDirectory.open(new File(indexDir));

IOContext ioContext = new IOContext(Context.DEFAULT);

return new RAMDirectory(fsDir, ioContext);

}



private void ikanalyzerIndex(String indexDir,String filesPath){

Analyzer analyzer = new IKAnalyzer(true);//可參IKAnalyzer說明

try {

Directory index = FSDirectory.open(new File(indexDir));

IOContext ioContext = new IOContext(Context.DEFAULT);

// Directory index = new RAMDirectory(fsDir, ioContext);

IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_43,analyzer);

IndexWriter w = new IndexWriter(index, config);

config.setMaxBufferedDocs(1000);//純粹測試效能調教

config.setRAMBufferSizeMB(40);//純粹測試效能調教

TvDocmentExtract tde = new TvDocmentExtract();

try {

List lists=tde.parseAllFilesInDirectory(new File(filesPath));

for(TvDocumentVo vo :lists){

this.addDocument(w,vo.getMetadata().get("filename"),vo.getContent());

}

w.close();

} catch (SAXException ex) {

Logger.getLogger(TvIndexManagement.class.getName()).log(Level.SEVERE, null, ex);

} catch (TikaException ex) {

Logger.getLogger(TvIndexManagement.class.getName()).log(Level.SEVERE, null, ex);

}

} catch (IOException ex) {

Logger.getLogger(TvIndexManagement.class.getName()).log(Level.SEVERE, null, ex);

}

}

private void addDocument(IndexWriter writer,String filename,String content) throws IOException{

Document doc = new Document();

//System.out.println(filename);

doc.add(new TextField("filename", filename, Field.Store.YES));

doc.add(new TextField("content", content, Field.Store.YES));

writer.addDocument(doc);

}

}

全文檢索範例程式碼

String querystr = "合法";

Directory index = FSDirectory.open(new File("D:\\index"));

Analyzer analyzer = new IKAnalyzer(true);

QueryParser qp = new QueryParser(Version.LUCENE_43, "content", analyzer);

qp.setDefaultOperator(QueryParser.Operator.AND);

Query q = qp.parse(querystr);

int hitsPerPage = 10;

IndexReader reader = DirectoryReader.open(index);

IndexSearcher searcher = new IndexSearcher(reader);

TopScoreDocCollector collector = TopScoreDocCollector.create(hitsPerPage, true);

searcher.search(q, collector);

ScoreDoc[] hits = collector.topDocs().scoreDocs;

collector.getTotalHits();

System.out.println("Found " + hits.length + " hits ==>" + collector.getTotalHits());

for (int i = 0; i < hits.length; ++i) {

int docId = hits[i].doc;

Document d = searcher.doc(docId);

System.out.println((i + 1) + ". " + d.get("filename"));

}

reader.close();

目前正在試試看，不使用Hadoop方式加快建立索引時間，基本上會用Queue方式進行，下次再介紹囉。

Java EE(一)：Glassfish JAAS JDBC Realm 設定 & SSO補充

2013-06-30T04:28:00.000-07:00

甚麼是JAAS可以參考一下JWorld@TW及Oracle Jaas，在進行專案開發時，基本上人員權限一定是考量進去的，這次來介紹一下如何在Glassfish專案中設定 jdbc realm的方式進行。

既然是jdbc當然要先規劃一下db schema，有三個資料表要建立，user(人員資料表)、role(角色群組表)、userrolemapping(人員角色對應表)，user資料表內要有帳號(username)及密碼(password)，role資料表角色代號(role_code)，userrolemapping資料表帳號(username)及角色代號(role_code)對應，這裡我會建議設計一個view比較方便：

SELECT user.username, user.password, role.role_code
FROM user, role, userrolemapping
WHERE user.username = userrolemapping.username AND role.role_code= userrolemapping.role_code;

若是JPA當然就用Id囉，

SELECT user.username, user.password, role.role_code
FROM user, role, userrolemapping
WHERE user.id= userrolemapping.user_id AND role.id= userrolemapping.role_id;

啟動Glassfis並進入admin console
http://localhost:4848

選擇資源(Resources)--JDBC-- JDBC Connection Pool，按下新增

Pool Name：test
資源類型：javax.sql.DataSource
資料庫驅動程式供應商：這裡使用Postgresql，就選Postgresql Driver。

按下Next

輸入以下特性，並按下確定。

可以測試是否設定正確，按下Ping進行測試。

新增JDBC資源，資源--JDBC--JDBC資源，按下新增

JNDI名稱：jdbc/test
池名稱：剛剛建立的Pool名稱即可。
輸入完畢後按下確定。

新增JDBCRealm，配置--server-config--安全性--範圍，按下新建，選擇JDBCRealm，

名稱：testAuth。
JAAS環境：jdbcRealm，這要注意就是jdbcRealm大小寫要一模一樣。
JNDI：jdbc/test，剛剛設定的JDBC名稱。主要用於連接資料庫使用。
使用表格名稱：view table名稱。
使用者名稱欄：username
密碼欄：password
群組表格：view table名稱。
群組名稱欄：role
摘要演算法：MD5，這裡要注意一下，Default為SHA-256，並注意資料表中密碼欄位請以MD5方式儲存，參考程式如下：

public String encoderByMd5(String str) throws UnsupportedEncodingException {
java.security.MessageDigest md5 = java.security.MessageDigest.getInstance("MD5");
return new String(org.apache.commons.codec.binary.Hex.encodeHex(md5.digest(str.getBytes())));

}

並按下儲存。

進行Application web.xml檔案設定，Netbeans中打開web.xml(也可以直接修改啦)，點選Security--Login Configuration，勾選選Form的選項

Form Login Page：輸入登入頁的路徑，請注意該頁面有幾個必要欄位，如下

Form Action：j_security_check
Form Input：j_username及j_password

Form Error Page：輸入登入失敗對應的路徑頁面。

Security Role：新增與role一樣的角色。

儲存檔案，重新啟動Glassfish，並Deploy Application，開啟Browser輸入Application網址，這時候應該不管輸入哪個網址都會redirect到Login的頁面囉。

SSO補充：

有時候會有多組Application需要access同一Realm做到SSO的情形，就可以在配置--server-config--虛擬伺服器--選擇你要SSO的Server，通常與Realm同一台，將SSO選項選擇已啟用，然後在其他特性中增加兩組特性。

sso-max-inactive-seconds：300

sso-reap-interval-seconds：60

按下儲存，重新啟動Glassfish，就可以兩組或兩組以上Application使用同一個realm，而且只要登入其中一組Application的Login頁面後，進入其他Application時就不用在登入了。

我愛Java EE

2013-06-22T01:55:00.000-07:00

Java EE 7千呼萬喚始出來，可以看看以下的連結喔

Java EE 7 at Glance
Developer Java EE 7
Java EE 7支援HTML 5

目前Java EE是我開發專案的最愛，真的真的很方便，又快速，但是在台灣使用的人目前還是算少的，我現在公司主流還是 Struts 2，我很努力很努力要引入Java EE，希望會有所成效咧。

我不太想花時間介紹 Java EE的架構，想知道的可以Google一下應該就會知道了，我這裡會介紹用Netbeans + Java EE開發專案的方式，當中也會帶一下我的想法，我個人是以實作Prototype以Live Demo方式推專案，或許會有人說這不是很浪費時間嗎？而且又不是一定會是給你做，其實我的想法是如下：

成功率較高：可以讓客戶看到東西，客戶會比較有感覺。
教育訓練：藉由Prototype可以訓練開發人員。
累積經驗：在客戶的回饋跟訓練過程中，可以調整專案開發的方式，也可以開發相關模組。

我一直說很快，那到底是如何快呢...就來做做看囉

先下載 Netbeans，現在是Netbeans 7.3(Netbeans7.3.1先不建議安裝)選擇All的那個下載囉，安裝Netbeans基本上都是Next就可以了。
安裝後就可以啟動Netbeans，到 File-- New Project -- Java Web(左)-- Web Application(右)按下Next

Project Name輸入FirstJavaEE，按下Next

接下來就要設定對應的Server、Java EE版本及Web的路徑了，這裡要注意的是因為是安裝Netbeans 7.3.1，所以預設安裝應該是Glassfish 4，在Java EE Version中可以選擇 Java EE 7或是6，我們這裡先用Java EE 6，之後我會在介紹Java EE 7，至於Context Path就以專案名稱就可以了，按下Next。

選擇Framework，JavaServer Faces當然是首選囉，勾選後會出現JSF的設定選項，可以都不設定就按Next，因為JSF的實作很多可以使用，我大部分都使用Primefaces，所以選擇Component頁簽勾選Primefaces，所以需要按下More選擇Primefaces Library，另外要注意因為使用Primefaces若是有檔案上傳需求，要把fileupload的jar放進專案中，有需要者可以點選下載，按下Finish，基本上就完成了一個JavaEE專案的設定了。

Deploy專案並開啟瀏覽器測試一下囉。

當然這樣還是不夠囉，進行CRUD頁面製作囉，先Create JPA(Model)，ProjectName按下滑鼠右鍵，選擇 New -- Entities Classes from database，於Data Source選擇jdbc/sample，然後再選擇Customer(左)將其Add過去，並按下Next，然後輸入Package，這裡先輸入sample.test，就一直Next下去直到Finish，它會產生對應資料表的Entities。

接下來就create JSF(View & Controllor)，rojectName按下滑鼠右鍵，選擇 New -- JSF Pages from Entities，把所有的Entities(左) Add All，然後按下Next及Finish。

進行測試，在customer目錄中的List.xhtml按下滑鼠右鍵Run File，有出現最後的畫面就是OK了，可以試試看可不可以增刪修囉，另外就是可以把元件改成Primefaces會更漂亮喔，下次再來介紹Primefaces。

mixare：Augmented Reality(AR) Open Source Library (一)

2013-06-20T00:32:00.000-07:00

上一篇介紹AR的概念，這次來介紹一下一些Open Source的Library-mixare，透過mixare就可以開發出一些東西囉，話不多說就先來用用看囉。

以App的方式進行開發，雖然說可以透過CCD使用，但是用行動裝置總是比較方便，而且mixare也是以App來介紹。

可以去下載Android SDK，現在已經有內含eclipse囉，就直接使用解壓縮後的eclipse。

先去下載 mixare source，選擇ZIP整個檔案下載，解壓縮後，先將mixare、mixare lib及其他的plugin import eclipse。

一開始相關project除了mixarelib project其他應該都有錯誤訊息，檢查一下bin目錄下有沒有mixarelib.jar，也可以直接執行build.xml產出。

mixare主專案中右鍵 Properties---Android應該會看到有紅色XX的標記，按下remove移除掉，並按下Add增加剛剛設定的mixarelib。

mixare主專案中有些錯誤，如getColour及implements介面少了一些method，修改一下就好了。把她Deploy到手機上就可以了，不過我覺得他有個Bug就是連不到相關的DataSources時就一直跳出錯誤訊息不是那麼好，連不到了不起就變成相機囉，這部分我會調整一下，之後在分享囉。

Augmented Reality(AR)擴增實境要起飛囉...

2013-06-08T19:59:00.001-07:00

因為公司每年都會舉辦創新競賽，讓大家可以提一些點子，看看有沒有市場機會，雖然我覺得技術創新遠比市場機會大，可是偶也不是老大，又為了獎金，所以囉為了五斗米折腰，原本是要提的是PhoneGap(之後也會介紹，是個好物啊!)，結果在搜尋時看到了wikitude ，就一路的看到AR這技術，它不算是新技術，很早就有人提出來了，但是隨著行動裝置的流行，這技術也被重新吵起來，然後Google Glass也算是推力。

它的概念其實是透過設備如手機上相機、眼鏡、CCD，將所看到的真實且即時的影像，混合虛擬的東西，如看到的人頭上找出角，戴上皇冠或是加上鬍子等等，如AR Toolkit、AR tag，若是在加上GPS及Compass，就可以增加區域地點及距離的判斷，如mixare、wikitude、DroidAR。

先介紹一下wikitude，網站上有提供SDK，目前有三種行動裝置的平台可以用，Android、iOS、BlackBlerry 10，也有PhoneGap的plugin，也就是可以走Hybird App的方式，進到網站可以看看showcase，最讓我感到興趣的是冰原歷險記的遊戲，大致上AR的應用遊戲是一個很好的方向；AR Toolkit、AR tag 有滿完整的API可以玩玩看，而且又是Open Source，不過相關的演算邏輯倒是很複雜，建議知道如何拿來用就好。

mixare 我個人認為是AR入門首選，因為有搭配行動裝置及資料格式有JSON，很容易與Web Ap搭配起來，稍稍修改一下增加一些圖像，就可以做出一些東西出來，之後陸續會先以這個來介紹AR。

metaio這最近才開始碰，跟wikitude很像，showcase的idea倒很實用。
最後總結一下，AR技術不會很困難，但他可提供出創意的腦力激盪，我個人認為AR一定很好用，但是創意則是出線的關鍵。

下一篇就來介紹 mixare的使用囉。

Jasig CAS SSO 安裝篇

2013-03-01T01:36:00.000-08:00

最近在玩SSO CAS，Open Source的Jasig CAS我覺得很好入手，之後就慢慢介紹囉。

先以Tomcat 7.0.37為Ap Server，

OS：Window。

先安裝JDK及安裝Tomcat。
再下載Jasig CAS Server，並解開壓縮檔。
解開後會有很多目錄，都是cas-server-xxxx這些都是source，若是有需求可以自行修改，然後用Maven修改。本次因為只有安裝所以就用modules的目錄就可以囉，複製cas-server-webapp-x.x.x.war到Tomcat\webapps目錄下。
先啟動Tomcat，正常的話應該是可以正常啟動，然後打開Browser輸入http://hostname:8080/cas-server-webapp-x.x.x/login，應該會看到登入畫面但是有警示，你要使用SSL表示快成功了。

設定Tomcat SSL步驟，進入Command line模式，

產生SSL Server憑證請求檔：

JAVA_HOME%\bin\keytool -genkey -alias tomcat -keypass changeit -keyalg RSA

匯出憑證請求檔：

%JAVA_HOME%\bin\keytool -export -alias tomcat -keypass changeit -file server.crt

%JAVA_HOME%\bin\keytool -import -file server.crt -keypass changeit -keystore %JAVA_HOME%/jre/lib/security/cacerts

建議先將%JAVA_HOME%/bin加入PATH中比較方便，過程中要注意一下關於產生的檔案及匯入CA時權限的問題，也要注意一下keystore的位置，Tomcat會用到。

將.keystore複製到指定目錄(可以自行指定)，修改Tomcat Server.xml尋找到被mark起來的

<Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true"

               maxThreads="150" scheme="https" secure="true"

               clientAuth="false" sslProtocol="TLS" />

改成

<Connector port="8443" protocol="org.apache.coyote.http11.Http11Protocol" SSLEnabled="true"

               maxThreads="150" scheme="https" secure="true"

               clientAuth="false" sslProtocol="TLS"

                keystorePass="changeit" keystoreFile="xxx.keystore"

               />

重新執行步驟4，應該原本警示的訊息沒有了，隨便輸入用戶名及密碼一樣的如用戶名 louisz密碼 louisz，正常的話應該會看到成功的訊息喔。

Pentaho kettle取指定目錄下的所有檔案

2013-01-22T00:55:00.002-08:00

最近開始玩 BI的東西，而之前專案有使用到Pentaho Open Source這個好物....

Pentaho裡面很多東西，跟 Jasperreport一樣東西很多，我最先接觸到的是kettle ETL的工具，玩了一陣子，開始有空就把它寫下來，以免忘記。

Scan一個目錄下所有檔案，然後塞進去資料庫

1.先拉兩個 Input，一個Get File Names，一個是CSV file input，再拉一個 output 中的 Table output，然後把他連起來。

2.點開 Get File Names，File or directory設定你的指定目錄，Regular Expression則是輸入.*\.*$則是所有檔案，若是CSV則可.*\.torrent$這可以了，可以按一下 Preview rows看看是否正確。

3.在CSV file input則於The filename field....下拉選單選擇filename，並於下方文字檔案格式部分依序輸入該文字檔案格式。這部分就是讓前一個步驟讀取所有檔案後，將檔名自動送進來，依據固定的格式讀入。

4.最後一個Table output就是塞到DB，把相關mapping設定一下就可以了。

Pentaho實在很讚，往後陸續增加囉。

Barcode Generator 條碼產生器 by ZXing

2012-10-09T01:47:00.003-07:00

ZXing還滿方便的，產生各式條碼跟讀取，可以參考一下。

這裡介紹QRCode的產生方式

1.下載 ZXing
2.解開會出現很多目錄，將core及javase裡面的core.jar及javase.jar檔案include進來
3.部分程式碼

import java.io.File;
import java.io.IOException;
import java.util.Hashtable;

import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.WriterException;
import com.google.zxing.client.j2se.MatrixToImageWriter;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
....

MultiFormatWriter writer = new MultiFormatWriter();
Hashtable hints = new Hashtable();
hints.put( EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.Q );
try {
MatrixToImageWriter.writeToFile( writer.encode( "Hello World", BarcodeFormat.QR_CODE, 800, 800, hints ),
"png", new File( "qrcode.png" ) );
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (WriterException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

很簡單吧....BarcodeFormat有很多樣式的條碼，也有CODE_39等等可以玩玩看喔

希望我能持之以恆的寫Blog下去....動力ㄚ....

使用Apache Http Server進行Proxy和LoadBalance (補充)

2012-04-09T02:41:00.003-07:00

1.補上直接使用source進行compile的流程

下載http-2.x.tar.gz檔案
tar xvf http-2.x.tar.gz進入目錄
./configure --prefix=安裝的目錄 --enable-mods-shard=most --enable-proxy --enable-proxy-ajp --enable-proxy-balancer --enable-proxy-connect --enable-proxy-ftp --enable-proxy-http --enable-rewrite
./make
./make install

後續就是設定httpd.conf檔案了.

2.設定balancer-manager,可以直接由Web監控load balance的情況,也可以控制

<Location /balancer-manager >

SetHandler balancer-manager
Order Deny,Allow
Deny from all
Allow from xxx ---->開放可以accesss的domain或是host
</Location >

連結到 http://http-server/balancer-manager

使用Apache Http Server進行Proxy和LoadB alance

2012-01-30T01:33:00.000-08:00

環境概述
OS：Linux
Apache Http Server：2.2.21
安裝可以使用rpm或是抓source下來compile，建議前者
rpm –ivh apache-http-xxx.rpm
這裡請注意一下安裝的版本
http.conf 參數設定
Proxy
<VirtualHost *:80>
ProxyPass targetPath fromPath | fromUrl
<VirtualHost/> 範例如下

<VirtualHost *:80>
ProxyPass /app http://DomainName或IP:8888/app
ProxyPassReverse /app http://DomainName或IP:8888/app
<VirtualHost/>

上述的參數設定為，將某主機的http通訊協定下的Web application(app)，對應到本台Web Server的app下。這樣的Proxy架構的設定對企業內的Web應用程式相當有用處，若是遇到Web Application Server掛點只需要修改Proxy對應，不需要動到dns等等，是個滿便宜的Proxy架構設定喔。﹝不過要注意Web Application要注意redirectc和forward等的撰寫，盡量不要有絕對IP的出現﹞

Load Balance

Header add Set-Cookie "ROUTEID=.%{BALANCER_WORKER_ROUTE}e; path=/" env=BALANCER_ROUTE_CHANGED

<Proxy balancer://cluster failonstatus=404,301,500 nofailover=Off>
BalancerMember http://DomainName1或IP1:8888/app route=1
BalancerMember http://DomainName2或IP2:9999/app route=2
ProxySet stickysession=ROUTEID

<Proxy/>

<VirtualHost *:80>
ProxyPass /appbalancer://cluster
ProxyPassReverse /app balancer://cluster
<VirtualHost/>

MQ PCF API簡介

2009-07-27T08:03:00.000-07:00

可以透過該API管理QMGR

MQAgent.java---

package cgw.mq.admin;

import cgw.mq.bean.MQManageBean;

import com.ibm.mq.MQEnvironment;

import com.ibm.mq.MQException;

import com.ibm.mq.pcf.PCFMessageAgent;

public class MQAgent {

private PCFMessageAgent agent;

public MQAgent(MQManageBean bean ,int ccsid){

//MQEnvironment.CCSID = ccsid;

try {

PCFMessageAgent agent = new PCFMessageAgent(bean.getMqm_ip(),bean.getMqm_port(),bean.getAdmin_channel());

} catch (MQException e) {

e.printStackTrace();

}

agent.setCharacterSet(ccsid);

}

public PCFMessageAgent getAgent() {

return agent;

}

public void close() throws MQException{

agent.disconnect();

}

MQManageBean.java---

package cgw.mq.bean;

public class MQManageBean {

private String mqm_ip;

private int mqm_port;

private String admin_channel;

public String getAdmin_channel() {

return admin_channel;

}

public void setAdmin_channel(String admin_channel) {

this.admin_channel = admin_channel;

}

public String getMqm_ip() {

return mqm_ip;

}

public void setMqm_ip(String mqm_ip) {

this.mqm_ip = mqm_ip;

}

public int getMqm_port() {

return mqm_port;

}

public void setMqm_port(int mqm_port) {

this.mqm_port = mqm_port;

}

MQChannel.java---

package cgw.mq.admin;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import cgw.mq.bean.MQChannelBean;

import cgw.mq.bean.MQManageBean;

import com.ibm.mq.MQException;

import com.ibm.mq.pcf.CMQC;

import com.ibm.mq.pcf.CMQCFC;

import com.ibm.mq.pcf.CMQXC;

import com.ibm.mq.pcf.PCFException;

import com.ibm.mq.pcf.PCFMessage;

import com.ibm.mq.pcf.PCFMessageAgent;

public class MQChannel {

private PCFMessageAgent agent;

private int[] attrs = { CMQCFC.MQCACH_CHANNEL_NAME,

CMQCFC.MQCACH_CONNECTION_NAME, CMQCFC.MQIACH_MSGS,

CMQCFC.MQCACH_LAST_MSG_DATE, CMQCFC.MQCACH_LAST_MSG_TIME,

CMQCFC.MQIACH_CHANNEL_STATUS, CMQCFC.MQIACH_CHANNEL_TYPE };

public static void main(String args[]) throws MQException {

MQManageBean bean = new MQManageBean();

bean.setMqm_ip("192.168.1.2");

bean.setMqm_port(1416);

bean.setAdmin_channel("SYSTEM.DEF.SVRCONN");

MQAgent agent = new MQAgent(bean, 950);

MQChannel mqc = new MQChannel();

// PCFMessageAgent agent = new PCFMessageAgent("testPcf");

mqc.setAgent(agent.getAgent());

try {

//mqc.startChannelListener();

MQChannelBean channelBean = new MQChannelBean();

channelBean.setChannelName("go");

channelBean.setChannelType(CMQXC.MQCHT_SVRCONN);

mqc.createChannel(channelBean);

} catch (PCFException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (MQException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

public List chkChannel(String targetChannel) {

ArrayList beanList = new ArrayList();

try {

PCFMessage request = new PCFMessage(

CMQCFC.MQCMD_INQUIRE_CHANNEL_STATUS);

request.addParameter(CMQCFC.MQCACH_CHANNEL_NAME, targetChannel);

request.addParameter(CMQCFC.MQIACH_CHANNEL_INSTANCE_TYPE,

CMQC.MQOT_CURRENT_CHANNEL);

request.addParameter(CMQCFC.MQIACH_CHANNEL_INSTANCE_ATTRS, attrs);

PCFMessage[] pcf_resp = getAgent().send(request);

for (int i = 0; i < pcf_resp.length; i++){

MQChannelBean bean = new MQChannelBean();

bean.setChannelName(pcf_resp[i]

.getStringParameterValue(CMQCFC.MQCACH_CHANNEL_NAME));

bean.setChannelType(pcf_resp[i]

.getIntParameterValue(CMQCFC.MQIACH_CHANNEL_TYPE));

bean

.setConnectionName(pcf_resp[i]

.getStringParameterValue(CMQCFC.MQCACH_CONNECTION_NAME));

bean.setMsgCount(pcf_resp[i]

.getIntParameterValue(CMQCFC.MQIACH_MSGS));

bean.setLastMsgDate(pcf_resp[i]

.getStringParameterValue(CMQCFC.MQCACH_LAST_MSG_DATE));

bean.setLastMsgTime(pcf_resp[i]

.getStringParameterValue(CMQCFC.MQCACH_LAST_MSG_TIME));

bean.setStatus(pcf_resp[i]

.getIntParameterValue(CMQCFC.MQIACH_CHANNEL_STATUS));

beanList.add(bean);

}

} catch (PCFException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (MQException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return beanList;

}

public void startChannelListener() throws PCFException, MQException, IOException{

PCFMessage channel_msg = new PCFMessage(CMQCFC.MQCMD_START_CHANNEL_LISTENER);

getAgent().send(channel_msg);

}

public void stopChannel(MQChannelBean bean) throws PCFException,

MQException, IOException {

PCFMessage channel_msg = new PCFMessage(CMQCFC.MQCMD_STOP_CHANNEL);

channel_msg.addParameter(CMQCFC.MQCACH_CHANNEL_NAME, bean

.getChannelName());

channel_msg.addParameter(CMQCFC.MQCACH_CONNECTION_NAME, bean

.getConnectionName());

getAgent().send(channel_msg);

}

public void startChannel(MQChannelBean bean) throws PCFException,

MQException, IOException {

PCFMessage channel_msg = new PCFMessage(CMQCFC.MQCMD_START_CHANNEL);

channel_msg.addParameter(CMQCFC.MQCACH_CHANNEL_NAME, bean

.getChannelName());

channel_msg.addParameter(CMQCFC.MQCACH_CONNECTION_NAME, bean

.getConnectionName());

getAgent().send(channel_msg);

}

public void createChannel(MQChannelBean bean) throws PCFException,

MQException, IOException {

PCFMessage channel_msg = new PCFMessage(CMQCFC.MQCMD_CREATE_CHANNEL);

channel_msg.addParameter(CMQCFC.MQCACH_CHANNEL_NAME, bean

.getChannelName());

channel_msg.addParameter(CMQCFC.MQIACH_CHANNEL_TYPE, bean

.getChannelType());

getAgent().send(channel_msg);

}

public PCFMessageAgent getAgent() {

return agent;

}

public void setAgent(PCFMessageAgent agent) {

this.agent = agent;

}

MQQueue.java---

package cgw.mq.admin;

import java.io.IOException;

import cgw.mq.bean.MQManageBean;

import com.ibm.mq.MQException;

import com.ibm.mq.pcf.CMQC;

import com.ibm.mq.pcf.CMQCFC;

import com.ibm.mq.pcf.PCFException;

import com.ibm.mq.pcf.PCFMessage;

import com.ibm.mq.pcf.PCFMessageAgent;

public class MQQueue {

private String targetQueue;

private int depth;

private PCFMessage pcf_req;

private PCFMessageAgent agent;

private int[] attrs = { CMQC.MQCA_Q_NAME, CMQC.MQIA_CURRENT_Q_DEPTH };

public static void main(String[] arg){

MQManageBean bean = new MQManageBean();

bean.setMqm_ip("192.168.1.1");

bean.setMqm_port(1414);

bean.setAdmin_channel("SYSTEM.DEF.SVRCONN");

MQAgent agent = new MQAgent(bean,950);

MQQueue mqq = new MQQueue();

mqq.setTargetQueue("TEST");

mqq.setAgent(agent.getAgent());

mqq.init();

try {

//mqq.createQueue();

//mqq.removeQueue();

//mqq.clearQueue();

} catch (PCFException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (MQException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

mqq.chkQueueDepth();

System.out.println(mqq.getDepth());

}

public void init(){

pcf_req = new PCFMessage(CMQCFC.MQCMD_INQUIRE_Q);

pcf_req.addParameter(CMQC.MQCA_Q_NAME, getTargetQueue());

pcf_req.addParameter(CMQC.MQIA_Q_TYPE, CMQC.MQQT_LOCAL);

pcf_req.addParameter(CMQCFC.MQIACF_Q_ATTRS, attrs);

}

public void chkQueueDepth(){

try {

PCFMessage[] pcf_resp = getAgent().send(getPcf_req());

for(int i = 0;i

String tmp = pcf_resp[i].getStringParameterValue(CMQC.MQCA_Q_NAME).trim();

if(getTargetQueue().equals(tmp)){

setDepth(pcf_resp[i].getIntParameterValue(CMQC.MQIA_CURRENT_Q_DEPTH));

}else{

setDepth(-1);

}

} catch (PCFException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (MQException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

public void createQueue() throws PCFException, MQException, IOException{

PCFMessage queue_msg = new PCFMessage(CMQCFC.MQCMD_CREATE_Q);

queue_msg.addParameter(CMQC.MQCA_Q_NAME, getTargetQueue());

queue_msg.addParameter(CMQC.MQIA_Q_TYPE, CMQC.MQQT_LOCAL);

getAgent().send(queue_msg);

}

public void removeQueue() throws PCFException, MQException, IOException{

PCFMessage queue_msg = new PCFMessage(CMQCFC.MQCMD_DELETE_Q);

queue_msg.addParameter(CMQC.MQCA_Q_NAME, getTargetQueue());

queue_msg.addParameter(CMQC.MQIA_Q_TYPE, CMQC.MQQT_LOCAL);

getAgent().send(queue_msg);

}

public void clearQueue() throws PCFException, MQException, IOException{

PCFMessage queue_msg = new PCFMessage(CMQCFC.MQCMD_CLEAR_Q);

queue_msg.addParameter(CMQC.MQCA_Q_NAME, getTargetQueue());

//queue_msg.addParameter(CMQC.MQIA_Q_TYPE, CMQC.MQQT_LOCAL);

getAgent().send(queue_msg);

}

public String getTargetQueue() {

return targetQueue;

}

public void setTargetQueue(String targetQueue) {

this.targetQueue = targetQueue;

}

public int getDepth() {

return depth;

}

public void setDepth(int depth) {

this.depth = depth;

}

public PCFMessage getPcf_req() {

return pcf_req;

}

public void setPcf_req(PCFMessage pcf_req) {

this.pcf_req = pcf_req;

}

public PCFMessageAgent getAgent() {

return agent;

}

public void setAgent(PCFMessageAgent agent) {

this.agent = agent;

}

package cgw.mq.admin;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import cgw.mq.bean.MQChannelBean;

import cgw.mq.bean.MQManageBean;

import com.ibm.mq.MQException;

import com.ibm.mq.pcf.CMQC;

import com.ibm.mq.pcf.CMQCFC;

import com.ibm.mq.pcf.CMQXC;

import com.ibm.mq.pcf.PCFException;

import com.ibm.mq.pcf.PCFMessage;

import com.ibm.mq.pcf.PCFMessageAgent;

public class MQChannel {

private PCFMessageAgent agent;

private int[] attrs = { CMQCFC.MQCACH_CHANNEL_NAME,

CMQCFC.MQCACH_CONNECTION_NAME, CMQCFC.MQIACH_MSGS,

CMQCFC.MQCACH_LAST_MSG_DATE, CMQCFC.MQCACH_LAST_MSG_TIME,

CMQCFC.MQIACH_CHANNEL_STATUS, CMQCFC.MQIACH_CHANNEL_TYPE };

public static void main(String args[]) throws MQException {

MQManageBean bean = new MQManageBean();

bean.setMqm_ip("192.168.1.2");

bean.setMqm_port(1416);

bean.setAdmin_channel("SYSTEM.DEF.SVRCONN");

MQAgent agent = new MQAgent(bean, 950);

MQChannel mqc = new MQChannel();

// PCFMessageAgent agent = new PCFMessageAgent("testPcf");

mqc.setAgent(agent.getAgent());

try {

//mqc.startChannelListener();

MQChannelBean channelBean = new MQChannelBean();

channelBean.setChannelName("go");

channelBean.setChannelType(CMQXC.MQCHT_SVRCONN);

mqc.createChannel(channelBean);

} catch (PCFException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (MQException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

public List chkChannel(String targetChannel) {

ArrayList beanList = new ArrayList();

try {

PCFMessage request = new PCFMessage(

CMQCFC.MQCMD_INQUIRE_CHANNEL_STATUS);

request.addParameter(CMQCFC.MQCACH_CHANNEL_NAME, targetChannel);

request.addParameter(CMQCFC.MQIACH_CHANNEL_INSTANCE_TYPE,

CMQC.MQOT_CURRENT_CHANNEL);

request.addParameter(CMQCFC.MQIACH_CHANNEL_INSTANCE_ATTRS, attrs);

PCFMessage[] pcf_resp = getAgent().send(request);

for (int i = 0; i <>

MQChannelBean bean = new MQChannelBean();

bean.setChannelName(pcf_resp[i]

.getStringParameterValue(CMQCFC.MQCACH_CHANNEL_NAME));

bean.setChannelType(pcf_resp[i]

.getIntParameterValue(CMQCFC.MQIACH_CHANNEL_TYPE));

bean

.setConnectionName(pcf_resp[i]

.getStringParameterValue(CMQCFC.MQCACH_CONNECTION_NAME));

bean.setMsgCount(pcf_resp[i]

.getIntParameterValue(CMQCFC.MQIACH_MSGS));

bean.setLastMsgDate(pcf_resp[i]

.getStringParameterValue(CMQCFC.MQCACH_LAST_MSG_DATE));

bean.setLastMsgTime(pcf_resp[i]

.getStringParameterValue(CMQCFC.MQCACH_LAST_MSG_TIME));

bean.setStatus(pcf_resp[i]

.getIntParameterValue(CMQCFC.MQIACH_CHANNEL_STATUS));

beanList.add(bean);

}

} catch (PCFException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (MQException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return beanList;

}

public void startChannelListener() throws PCFException, MQException, IOException{

PCFMessage channel_msg = new PCFMessage(CMQCFC.MQCMD_START_CHANNEL_LISTENER);

getAgent().send(channel_msg);

}

public void stopChannel(MQChannelBean bean) throws PCFException,

MQException, IOException {

PCFMessage channel_msg = new PCFMessage(CMQCFC.MQCMD_STOP_CHANNEL);

channel_msg.addParameter(CMQCFC.MQCACH_CHANNEL_NAME, bean

.getChannelName());

channel_msg.addParameter(CMQCFC.MQCACH_CONNECTION_NAME, bean

.getConnectionName());

getAgent().send(channel_msg);

}

public void startChannel(MQChannelBean bean) throws PCFException,

MQException, IOException {

PCFMessage channel_msg = new PCFMessage(CMQCFC.MQCMD_START_CHANNEL);

channel_msg.addParameter(CMQCFC.MQCACH_CHANNEL_NAME, bean

.getChannelName());

channel_msg.addParameter(CMQCFC.MQCACH_CONNECTION_NAME, bean

.getConnectionName());

getAgent().send(channel_msg);

}

public void createChannel(MQChannelBean bean) throws PCFException,

MQException, IOException {

PCFMessage channel_msg = new PCFMessage(CMQCFC.MQCMD_CREATE_CHANNEL);

channel_msg.addParameter(CMQCFC.MQCACH_CHANNEL_NAME, bean

.getChannelName());

channel_msg.addParameter(CMQCFC.MQIACH_CHANNEL_TYPE, bean

.getChannelType());

getAgent().send(channel_msg);

}

public PCFMessageAgent getAgent() {

return agent;

}

public void setAgent(PCFMessageAgent agent) {

this.agent = agent;

}

利用Asprise OCR辨識PDF中的條碼

2009-03-09T01:15:00.000-07:00

http://asprise.com/product/ocr/index.php?lang=java
這個API還滿不錯用的，它可以直接辨識PDF中的條碼，不過Free的版本跟文件似乎有些不一樣，底下是辨識PDF文件的條碼步驟：
1.下載Asprise OCR v4.0 for Java，http://asprise.com/product/ocr/download.php?lang=java，以及AspriseJavaPDF-free.jar，http://asprise.com/product/javapdf/util.php
2.有Developer Guide手冊可以參考一下，把AspriseOCR.dll、DevIL.dll及ILU.dll放在LIBRARY(如Window/system32或是project的lib)
3.程式碼如下
OCR ocr = new OCR();
PDFReader pdfreader = new PDFReader(new File("d:\\lunch.pdf"));
pdfreader.open();
int pageCount = pdfreader.getNumberOfPages();
// PDFToImage pdfToImage = new PDFToImage("D:\\lunch.pdf");
pdfreader.close();
PDFToImage pdfToImage = new PDFToImage("D:\\lunch.pdf");
for(int j=1;j
BufferedImage img = pdfToImage.getImage(j);
String text=ocr.recognizeBarcode(img);
//Vector v = ocr.recognizeBarcodes(img);
System.out.println(text);
}
一頁是多個條碼時，可以用Vector就可以了，滿方便的不過不用錢的每辨識一頁就會跳出一個版權視窗按下否或是，才會往下辨識，比較麻煩一點

XEN on CentOS

2009-02-19T22:20:00.000-08:00

最近因為我申請的開發機器下來了，就玩玩之前沒測完的XEN，先說一下我機器的配備應該算是很高檔.

CPU---QC * 2 ---共8核
RAM---12GB
硬碟----3顆1T

有三台(呵呵很酷喔而且還只拿來開發)

回到正題，上次XEN少了Window，這次給他補足了順便紀錄一下遇到的一些問題
1.要在XEN安裝Window系列，Intel CPU要具備VT，AMD要具備AMD-V如何確認呢
cat /proc/cpuinfo | grep flags
看看有沒有VMX的項目，有就可以安裝.
p.s這裡還要注意一點若是CPU有註明有VT或是AMD-V可是下該指令沒有的話就請確認核心有沒有開啟(SuSe 11.1就沒有)

2.強烈建議使用CentOS5.2進行，OpenSuSe我分別裝了10.1 - 10.3及11統統不行在XEN裡裝Window，CentOS5.2很順。

3.網路設定問題
a.希望外部可以直接連到虛擬機器(domainU)，安裝CentOS時先不要在實體網路卡上設定任何IP，但實體線路可以插上去，然後再安裝CentOS，起動虛擬機器管理員(是圖形介面)，連接並建立一新的DomainU，依據所需進行設定，到了Host network設定時請選擇第二項shard physical network，就一路安裝下去囉..安裝好DomainU的作業環境，然後再設定網路卡的IP(DomainU的)應該就可以囉.
※這裡可以把DomainO(CentOS)的網路卡當做一個HUB來看就不難理解他不用設IP了，可是不要問我原因我也不知道

b.希望走DHCP方式同a步驟，到Host network請選擇第一項virtual network後面步驟就一樣了，可是要外部連到這台機器時，則要在DominO(CentOS)上利用iptables進行囉

4.可以使用virt-clone進行複製好用喔

IReport中的條碼類別BcImage

2009-01-13T23:04:00.000-08:00

最近有一個繳費單的專案，需要列印條碼，因為IReport本身就有提供列印條碼的功能，所以就用IReport設計繳費單然後再用Jasperreport API寫批次程式去產生PDF，資料量大概3000多筆(頁)拆成幾個檔案，可是就發生了一個問題居然發生部分繳費單的條碼有問題，看了一下程式研判是Race Condition因為程式採用的是多執行緒，若是依序個別產生是不會有問題，但是同時執行的時候就會亂掉，而且都錯在條碼，令我覺得很奇怪，後來我查了一下發現it.businesslogic.ireport.barcode.BcImage 類別我猜是這裡的問題，就先加上synchronized重新編譯在去執行，嘿嘿條碼就對了，做了一下壓測也正常，程式碼如下，不過這樣事不是對了可能還要仔細查查看。

public class BcImage {
private static net.sourceforge.barbecue.Barcode bc = null;

public synchronized static net.sourceforge.barbecue.Barcode getBarcode() {
return bc;
}

public synchronized static BufferedImage getBarcodeImage(int type, Object aText, boolean showText, boolean checkSum) {
return getBarcodeImage(type, aText, showText, checkSum,"",0,0);
}

public synchronized static BufferedImage getBarcodeImage(int type, Object aText, boolean showText, boolean checkSum, String applicationIdentifier, int width, int height) {
// 2of7, 3of9, Bookland, Codabar, Code128, Code128A, Code128B, Code128C, Code39, EAN128, EAN13, GlobalTradeItemNumber, Int2of5, Int2of5, Monarch, NW7, PDF417, SCC14ShippingCode, ShipmentIdentificationNumber, SSCC18, Std2of5, Std2of5, UCC128, UPCA, USD3, USD4, USPS

String text = new StringBuffer().append(aText).toString();

try {
switch (type) {
case 0: return null;
case 1: bc = BarcodeFactory.create2of7(text); break;
case 2: bc = BarcodeFactory.create3of9(text, checkSum); break;
case 3: bc = BarcodeFactory.createBookland(text); break;
case 4: bc = BarcodeFactory.createCodabar(text); break;
case 5: bc = BarcodeFactory.createCode128(text); break;
case 6: bc = BarcodeFactory.createCode128A(text); break;
case 7: bc = BarcodeFactory.createCode128B(text); break;
case 8: bc = BarcodeFactory.createCode128C(text); break;
case 9: bc = BarcodeFactory.createCode39(text, checkSum ); break;
case 10: bc = BarcodeFactory.createEAN128(text); break;
case 11: bc = BarcodeFactory.createEAN13(text); break;
case 12: bc = BarcodeFactory.createGlobalTradeItemNumber(text); break;
case 13: bc = BarcodeFactory.createInt2of5(text, checkSum); break;
case 14: bc = BarcodeFactory.createMonarch(text); break;
case 15: bc = BarcodeFactory.createNW7(text); break;
case 16: bc = BarcodeFactory.createPDF417(text); break;
case 17: bc = BarcodeFactory.createSCC14ShippingCode(text); break;
case 18: bc = BarcodeFactory.createShipmentIdentificationNumber(text); break;
case 19: bc = new UCCEAN128Barcode(UCCEAN128Barcode.SSCC_18_AI, text, checkSum); break; //BarcodeFactory.createSSCC18(text); break;
case 20: bc = BarcodeFactory.createStd2of5(text, checkSum); break;
case 21: bc = new UCCEAN128Barcode(applicationIdentifier, text, checkSum); break; //BarcodeFactory.createUCC128(applicationIdentifier, text); break;
case 22: bc = BarcodeFactory.createUPCA(text); break;
case 23: bc = BarcodeFactory.createUSD3(text, checkSum); break;
case 24: bc = BarcodeFactory.createUSD4(text); break;
case 25: bc = BarcodeFactory.createUSPS(text); break;
case 26: bc = new net.sourceforge.barbecue.linear.code39.Code39Barcode(text, checkSum, true); break;
}

if (width > 0) bc.setBarWidth(width);
if (height > 0) bc.setBarHeight(height);
bc.setDrawingText(showText);
return net.sourceforge.barbecue.BarcodeImageHandler.getImage(bc);
}
catch (Exception e) {
e.printStackTrace();
//generate a runtime exception, invalid value passed.
//the user must be notified if fail
throw new RuntimeException(e.getMessage());
//return null;
}
}
}

IReport透過寫程式自訂功能

2008-12-02T20:45:00.000-08:00

IReport是透過SQL進行資料的取得，所以很多邏輯都需要靠SQL來進行，有時候只是要進行一個資料的對應大部分都是透過join table進行，或是需要另一資料來源時就需要特別客製化應用程式等等，假如IReport可以呼叫Java程式那就非常之完美了，舉個例子說

原本在IReport中的SQL為

select a.name,b.className,c.countryName,a.telephone from student a ,class b,country c where a.id = b.id and a.id=c.id

若是b 跟 c不再同一個資料來源怎麼辦?

步驟

1.寫一隻Java程式可以連到其他資料來源,並把它包成jar檔案

2.將該jar檔案放在IReport的lib下

3.透過SQL去呼叫如

select name,test.ClassUtils.getClassName(id),test.CountryUtils.getCountry(countryId),test.TranUtils.translate(telephone) from student

這樣就可以了若是在搭配scriptlet方式進行那就真的很Power.

P.S 應用程式使用時也只要把jar放在classpath也可以喔~~

玩玩DES及RSA

2008-11-30T22:12:00.000-08:00

最近有個需求,就是希望能把儲存在文字檔中的密碼,增加一些安全機制,想說之前(參考JavaWorld@TW的一些資料)有玩過一下下DES及RSA說不定可以試試看，流程大概先產生一把KEY(DES)或是一對KEY(RSA),使用KEY針對資料進行加密,加過密的文字有可能會是非法字元,所以用BASE64進行encode或是decode,應用程式要使用加個密的資料,需要兩個要素第一個就是key,另外就是API,缺一不可(盡量防止Developer).

DES部分

DESGenerator

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectOutputStream;

import java.security.NoSuchAlgorithmException;

import java.security.NoSuchProviderException;

import java.security.SecureRandom;

import java.security.spec.InvalidKeySpecException;

import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey;

import javax.crypto.SecretKeyFactory;

import javax.crypto.spec.DESKeySpec;

import entiebank.utils.Utils;

public class DESKeyGenerator {

public static void genDESKey(String keyFileName,String alg){

try {

KeyGenerator kpg = KeyGenerator.getInstance(alg);

//TODO Default alg maybe can change

//SecureRandom random = SecureRandom.getInstance("SHA1PRNG","SUN");

//常用的

// random.setSeed(101L);

// kpg.init(56,random);

SecretKey sKey = kpg.generateKey();

System.out.println(sKey.hashCode());

// SecretKeyFactory kfactory = SecretKeyFactory.getInstance(alg);

//DESKeySpec kspec = (DESKeySpec)kfactory.getKeySpec(sKey, DESKeySpec.class);

Utils.writeKeyFile(keyFileName, sKey);

//output File

// FileOutputStream fos = new FileOutputStream(keyFileName);

// ObjectOutputStream oos = new ObjectOutputStream(fos);

// oos.writeObject(sKey);

// oos.close();

//// fos.write(sKey.getEncoded());

// fos.close();

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

public static void main(String[] arg){

DESKeyGenerator.genDESKey("louisz.des", "DES");

}

DESUtils

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.security.InvalidKeyException;

import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;

import javax.crypto.SecretKey;

import javax.crypto.spec.DESKeySpec;

import entiebank.utils.Utils;

import sun.misc.BASE64Decoder;

import sun.misc.BASE64Encoder;

public class DESUtils {

private static SecretKey sKey = null;

public static void loadDESKey(String keyFileName){

sKey = (SecretKey)Utils.readKeyFile(keyFileName);

}

private static void readKey(){

System.out.println(sKey.hashCode());

}

public static SecretKey getDESKey(){

return sKey;

}

public static String encrypt(String clearString){

try {

Cipher desCipher = Cipher.getInstance("DES/ECB/PKCS5Padding");

desCipher.init(Cipher.ENCRYPT_MODE,getDESKey());

//System.out.println("clearStr="+encryptString);

//System.out.println("encrypt=="+new String(desCipher.doFinal(encryptString.getBytes())));

return bytesToBase64Str(desCipher.doFinal(clearString.getBytes()));

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidKeyException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IllegalBlockSizeException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BadPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

public static String decrypt(String encryptString){

try {

Cipher desCipher = Cipher.getInstance("DES/ECB/PKCS5Padding");

desCipher.init(Cipher.DECRYPT_MODE,getDESKey());

return new String(desCipher.doFinal(base64StrToBytes(encryptString)));

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IllegalBlockSizeException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BadPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidKeyException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

public static String decrypt(String keyFilename,String encryptString){

try {

SecretKey desKey = (SecretKey)Utils.readKeyFile(keyFilename);

Cipher desCipher = Cipher.getInstance("DES/ECB/PKCS5Padding");

desCipher.init(Cipher.DECRYPT_MODE,desKey);

return new String(desCipher.doFinal(base64StrToBytes(encryptString)));

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IllegalBlockSizeException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BadPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidKeyException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

public static String bytesToBase64Str(byte[] bytes){

return new BASE64Encoder().encode(bytes);

}

public static byte[] base64StrToBytes(String base64Str){

try {

return new BASE64Decoder().decodeBuffer(base64Str);

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

public static void main(String[] arg){

// DESUtils des = new DESUtils();

DESUtils.loadDESKey("Key");

DESUtils.readKey();

//System.out.println(DESUtils.encrypt("hehe it's can works"));

System.out.println(DESUtils.decrypt("l+M1yV2Mf4yaTlSxmPU3GA=="));

}

RSA部分

RSAGenerator

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.NoSuchProviderException;

import java.security.PrivateKey;

import java.security.PublicKey;

import entiebank.utils.Utils;

public class RSAKeyGenerator {

public static void genRSAPairKey(String keyFileName,String alg){

try {

KeyPairGenerator keyGen = KeyPairGenerator.getInstance(alg);

keyGen.initialize(1024);

KeyPair keyPair =keyGen.generateKeyPair();

PublicKey pubKey = keyPair.getPublic();

System.out.println(pubKey.hashCode());

Utils.writeKeyFile(keyFileName+".pub", pubKey);

PrivateKey priKey= keyPair.getPrivate();

System.out.println(priKey.hashCode());

Utils.writeKeyFile(keyFileName+".pri", priKey);

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

public static void main(String[] arg){

RSAKeyGenerator.genRSAPairKey("louisz","RSA");

}

RSAUtils

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.security.InvalidKeyException;

import java.security.NoSuchAlgorithmException;

import java.security.PrivateKey;

import java.security.PublicKey;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;

import javax.crypto.SecretKey;

import entiebank.security.des.DESUtils;

import entiebank.utils.Utils;

public class RSAUtils {

private static PublicKey pubKey = null;

private static PrivateKey priKey = null;

public static void loadRSAPubKey(String keyFileName){

pubKey=(PublicKey)Utils.readKeyFile(keyFileName);

}

public static void loadRSAPriKey(String keyFileName){

priKey=(PrivateKey)Utils.readKeyFile(keyFileName);

}

public static PublicKey getPublicKey(){

return pubKey;

}

public static PrivateKey getPrivateKey(){

return priKey;

}

public static String encrypt(String clearString){

try {

Cipher desCipher = Cipher.getInstance("RSA");

desCipher.init(Cipher.ENCRYPT_MODE,getPublicKey());

//System.out.println("clearStr="+encryptString);

//System.out.println("encrypt=="+new String(desCipher.doFinal(encryptString.getBytes())));

return Utils.bytesToBase64Str(desCipher.doFinal(clearString.getBytes()));

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidKeyException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IllegalBlockSizeException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BadPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

public static String decrypt(String encryptString){

try {

Cipher desCipher = Cipher.getInstance("RSA");

desCipher.init(Cipher.DECRYPT_MODE,getPrivateKey());

return new String(desCipher.doFinal(Utils.base64StrToBytes(encryptString)));

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IllegalBlockSizeException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BadPaddingException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidKeyException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

public static void main(String[] arg){

//RSAUtils rsa = new RSAUtils();

RSAUtils.loadRSAPriKey("louisz.pri");

RSAUtils.loadRSAPubKey("louisz.pub");

System.out.println(RSAUtils.encrypt("hehe it's can works"));

//System.out.println(rsa.decrypt("m/krh4KOgSNrDWpUrgUQ0ifVYmBnDAhdYU/B9HFZGiPsHDKOob/oQaJWyQX0a+VrC4igFq2a7zERrqUBjrImGgknMgjlko6NAufOHMu4BP4wblY68pIFPdIb1VZrN38vLgrtUjk1eXok7akn89Lu6NksBrlKoYEy2rOW/BfrCGs="));

}

Utils

import java.io.BufferedInputStream;

import java.io.BufferedReader;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import javax.crypto.SecretKey;

import sun.misc.BASE64Decoder;

import sun.misc.BASE64Encoder;

public class Utils {

public static Object readKeyFile(String keyFileName){

Object obj = null;

try {

FileInputStream fin = new FileInputStream(keyFileName);

ObjectInputStream ios = new ObjectInputStream(fin);

// DESKeySpec kSpec = (DESKeySpec)ios.readObject();

// kSpec.getKey();

obj= ios.readObject();

ios.close();

fin.close();

return obj;

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (ClassNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

public static void writeKeyFile(String keyFileName,Object sKey){

try {

FileOutputStream fos = new FileOutputStream(keyFileName);

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(sKey);

oos.close();

// fos.write(sKey.getEncoded());

fos.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

public static String bytesToBase64Str(byte[] bytes){

return new BASE64Encoder().encode(bytes);

}

public static byte[] base64StrToBytes(String base64Str){

try {

return new BASE64Decoder().decodeBuffer(base64Str);

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return null;

}

IReport use stored procedure

2008-11-24T22:21:00.000-08:00

很簡單

{call stored_procedure("param1", "param2"...) }

這樣就可以了，會以回傳ResultSet的方式進行，下一步則可以看到回傳的欄位

JMeter設定JDBC連線測試

2008-11-24T00:22:00.000-08:00

1.先將欲測試的JDBC驅動程式放在Jmeter/lib下

2.啟動Jmeter，滑鼠右鍵於【測試計畫】新增【執行緒群組】新增【設定元素】選擇【JDBC連線設定】相關設定說明如下

名稱：連線設定名稱

變數名稱：為該JDBC連線的變數，請以英數字為主

資料庫URL設定：欲連接的資料庫及JDBC的URL設定

JDBC驅動程式：欲測試的JDBC驅動程式的Driver名稱

使用者：資料庫連線使用者

密碼：上述使用者之密碼

其他設定可採用預設質或是依據所需進行設定

3.於【執行緒群組】新增【JDBC要求】相關設定如下

名稱：JDBC要求名稱

變數名稱：請使用JDBC連線設定的變數名稱

Query Type：請依所需使用囉

查詢：請輸入需要測試的SQL

4.於【執行緒群組】中【接聽】新增所需要看到的測試結果，例如檢視結果、檢視表格式結果等等

5.先測試相關設定有無問題，於【執行】中執行【開始】，在檢視結果中看看是否都是綠燈號誌

6.再依據所需於【執行緒群組】中設定測試數值再執行