Todd

2016-01-13T11:16:00.003+08:00

一對多的table, 如何只捉，多的那邊，其中一筆呢?

原來有下面寫法

select * from users join widgets on widgets.id = (
select id from widgets
where widgets.user_id = users.id
order by created_at desc
limit 1
)

還有其他方法
Ref : https://www.periscopedata.com/blog/4-ways-to-join-only-the-first-row-in-sql.html

mongodb embedded documents query for spring data

2015-12-30T10:24:00.003+08:00

mongodb embedded documents query for spring data

1.Aggreation

db.user.aggregate(

{ $match : {'_id': 1}},

{ $project: {'friendUserList': 1 }},

{ $unwind: "$friendUserList" },

{ $match : {'friendUserList.state': 'INIT'}},

{ $group: { _id: "result", count: { $sum: 1 }}}

);

Aggregation aggregation = newAggregation(

match(Criteria.where("_id").is(1)),

project("friendUserList"),

unwind("friendUserList"),

match(Criteria.where("friendUserList.state").is("INIT")),

group("friendUserList").count().as("count")

);

AggregationResults<User> result =

mongoOperations.aggregate(aggregation, "user", User.class);

return (long) result.getMappedResults().size();

mongodb embedded documents query

2015-12-30T10:24:00.002+08:00

mongodb embedded documents query example

schema

{
"_id" : NumberLong(1),
"_class" : "User",
"account" : "todd1",
"friendUserList" : [
{
"userId" : NumberLong(2),
"userAccount" : "todd2",
"state" : "AGREE"
},
{
"userId" : NumberLong(3),
"userAccount" : "todd3",
"state" : "INIT"
},
{
"userId" : NumberLong(5),
"userAccount" : "todd4",
"state" : "INIT"
}
]
}

{
"_id" : NumberLong(2),
"_class" : "User",
"account" : "todd2",
"friendUserList" : [
{
"userId" : NumberLong(6),
"userAccount" : "todd6",
"state" : "AGREE"
},
{
"userId" : NumberLong(7),
"userAccount" : "todd7",
"state" : "INIT"
}
]
}

Query

1.embedded document 只要有符合，整個document
db.user.find({
friendUserList : {
$elemMatch : {
state : 'INIT'
}
}
})

但這樣方式，直接這樣寫效果相同
db.user.find( { 'friendUserList.state': 'INIT' } )

2.指定條件與回傳的欄位
db.user.find({ '_id': 1 }, {'account': 1, 'friendUserList': 1});

3. match 先搜尋符合條件，但加總embedded的數量
db.user.aggregate(
{ $match : {'friendUserList.state': 'INIT'}},
{ $project: {'friendUserList': 1 }},
{ $unwind: "$friendUserList" },
{ $group: { _id: "result", count: { $sum: 1 }}}
);

{

"result" : [

{

"_id" : "result",

"count" : 5.0000000000000000

}

"ok" : 1.0000000000000000

}

所以若執行

db.user.aggregate(
{ $match : {'friendUserList.state': 'AGREE'}},
{ $project: {'friendUserList': 1 }},
{ $unwind: "$friendUserList" },
{ $group: { _id: "result", count: { $sum: 1 }}}
);

回傳count 也會是 5

再加個條件 id = 1 來驗證看看

db.user.aggregate(

{ $match : {'friendUserList.state': 'AGREE', '_id': 1}},

{ $project: {'friendUserList': 1 }},

{ $unwind: "$friendUserList" },

{ $group: { _id: "result", count: { $sum: 1 }}}

);

{

"result" : [

{

"_id" : "result",

"count" : 3.0000000000000000

}

"ok" : 1.0000000000000000

}

4.使用mongodb提供的count function

db.user.count( { account: 'todd1' } )

回傳會是1

db.user.count( { 'friendUserList.state': 'AGREE' } )

回傳會是2

但這還是以root document為單位來看

5.只加總 embedded document 符合條件的數量

目前只試出使用aggregate的方式

db.user.aggregate(

{ $match : {'_id': 1}},

{ $project: {'friendUserList': 1 }},

{ $unwind: "$friendUserList" },

{ $match : {'friendUserList.state': 'INIT'}},

{ $group: { _id: "result", count: { $sum: 1 }}}

);

{

"result" : [

{

"_id" : "result",

"count" : 2.0000000000000000

}

"ok" : 1.0000000000000000

}

Create centos6 USB installer on Mac

2015-06-23T17:24:00.003+08:00

原本想使用unetbootin來製做USB安裝程式，但搞老半天，
安裝到一半，就是會出現錯誤訊息

官網有講由 CentOS 6.5 起，你只需透過 dd 把 ISO 檔移至 USB 儲存器，便能利用它進行安裝

所以打開MAC

1.看看掛載的情況 diskutil list

/dev/disk2 就是隨身碟

2.卸載 diskutil unmountDisk /dev/disk2

3.用官網教的指令就能製做出來了

sudo dd if=CentOS-6.5-x86_64-minimal.iso of=/dev/disk2 bs=1m

AWS EC2 Build Tomcat And Single MongoDB

2015-06-19T14:59:00.002+08:00

價格試算

EC2

1.註冊

2.進到console home後，選Region

3.Launch Instance

Key Pairs

產生[name].pem，並下載，登入時要用

Security groups

增加SSH TCP 22 PORT

會自己建立一個VPC

4.產生後，回到Instances 頁面

就會新增剛才建立的，可選上方的Connect，可以用 ssh [ubuntu]@[public_ip] -i $PATH/[name].pem 來登入

5.登入後，安裝tomcat, 放程式

sudo apt-get update
sudo apt-get install tomat7

/usr/share/tomcat7
/var/log/tomcat7
/etc/tomcat7

sudo service tomcat7 start
sudo apt-get install default-jdk
sudo apt-get install maven
git clone https://xxx@code.google.com/p/projectname/
git pull
./sudo mvn clean
./sudo mvn install

sudo vim /etc/tomcat7/server.xml

Mongodb

1.可由Launch Instance選擇AMI 或 Service -> CloudFormation 使用template來建立

先簡單化，這裡使用template, 並安裝在原來的VPC上，
且Replica Set只建一個

安裝過程中
Subnet-xxxxxx 要輸入 Network Interface 頁面裡同一個VPC所對應的Subnet ID

會產一個新的instance

同樣方式連進去
ssh [ubuntu]@[public_ip] -i $PATH/name.pem

登入後，執行command

mongo
config = { _id: "r0", members: [ { _id:0, host:"127.0.0.1:27017" }] }
use testdb
db.createUser("root","password")

Send Email

選Service -> SES -> SMTP Settings
1.Server Name
2.Create My SMTP Credentials 要認證過的email，才收的到信

3.上線前，需於Support Center寫信給官方，才能離開sandbox

Ref

April 2015

https://s3.amazonaws.com/quickstart-reference/mongodb/latest/doc/MongoDB_on_the_AWS_Cloud.pdf

org.springframework.web.context.ContextLoaderListener

2014-10-26T22:19:00.000+08:00

使用 Spring 3.2.x 時, 只要一讀取

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

就會出現下面Exception

原來是因為我Tomcat使用了JDK1.8
若要用1.8, Spring必須upgrade成4才會支援1.8的byte code format

--
ERROR [org.springframework.web.context.ContextLoader] - <Context initialization failed>
java.lang.IllegalArgumentException
at org.springframework.asm.ClassReader.<init>(Unknown Source)
at org.springframework.asm.ClassReader.<init>(Unknown Source)
at org.springframework.asm.ClassReader.<init>(Unknown Source)

嚴重: Exception sending context initialized event to listener instance of class org.springframework.web.context.ContextLoaderListener
java.lang.IllegalArgumentException
at org.springframework.asm.ClassReader.<init>(Unknown Source)
at org.springframework.asm.ClassReader.<init>(Unknown Source)
at org.springframework.asm.ClassReader.<init>(Unknown Source)

2014-10-26 22:00:13,255 WARN [org.springframework.web.context.support.XmlWebApplicationContext] - <Exception thrown from ApplicationListener handling ContextClosedEvent>

java.lang.IllegalStateException: ApplicationEventMulticaster not initialized - call 'refresh' before multicasting events via the context: Root WebApplicationContext: startup date

at org.springframework.context.support.AbstractApplicationContext.getApplicationEventMulticaster(AbstractApplicationContext.java:347)

at org.springframework.context.support.AbstractApplicationContext.publishEvent(AbstractApplicationContext.java:334)

[org.springframework.web.context.support.XmlWebApplicationContext] - <Exception thrown from LifecycleProcessor on context close>

java.lang.IllegalStateException: LifecycleProcessor not initialized - call 'refresh' before invoking lifecycle methods via the context: Root WebApplicationContext: startup date

at org.springframework.context.support.AbstractApplicationContext.getLifecycleProcessor(AbstractApplicationContext.java:360)

at org.springframework.context.support.AbstractApplicationContext.doClose(AbstractApplicationContext.java:1057)

at org.springframework.context.support.AbstractApplicationContext.close(AbstractApplicationContext.java:1010)

Design Pattern - CQRS

2014-09-10T15:30:00.000+08:00

CQRS

ref:
http://johnnycoder.com/blog/2009/12/18/learn-domain-driven-design/
http://www.codeproject.com/Articles/555855/Introduction-to-CQRS

通常進行CRUD會有二個問題
collaboration 同時操作相同資料時
staleness 某筆資料, 當A查詢後, B修改

主要是想把二者責任分離
Command
Query

image source : http://www.udidahan.com/2009/12/09/clarified-cqrs/

image source : http://www.codeproject.com/Articles/555855/Introduction-to-CQRS

image source : http://msdn.microsoft.com/en-us/library/jj591573.aspx

Facebook 自訂分享按鈕

2014-09-05T18:03:00.004+08:00

1.在html tag內加入 xmlns:og、xmlns:fb屬性
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:og="http://ogp.me/ns#"
xmlns:fb="http://www.facebook.com/2008/fbml">

2.head tag加入
<meta name="og:description" content="" />
<meta property="og:title" content=""/>
<meta property="og:type" content="website"/>
<meta property="og:url" content=""/>
<meta property="og:image" content=""/> 縮圖, 可設定多圖
<meta property="og:site_name" content="" />
<meta property="fb:app_id" content="" />
<meta property="fb:admins" content=""/>

3.body tag裡面加入
<div id="fb-root"></div>
<script>
window.fbAsyncInit = function() {
FB.init({appId: 'app id', status: true, cookie: true, xfbml: true});
};
(function() {
var e = document.createElement('script'); e.async = true;
e.src = document.location.protocol + '//connect.facebook.net/zh_TW/all.js';
document.getElementById('fb-root').appendChild(e);
}());
</script>

4.清除facebook cache
https://developers.facebook.com/tools/debug

5.在要點擊分享的按鈕加上
<a href="https://www.facebook.com/sharer/sharer.php?u=url" target="_blank">分享到FACEBOOK</a>
或
<a target="_blank" onclick="return !window.open(this.href, 'Facebook', 'width=640,height=300')" href="http://www.facebook.com/sharer/sharer.php?u=url">分享到FACEBOOK</a>

補充
1.自動產生連結網站 http://www.sharelinkgenerator.com/

Subclipse

2012-03-07T13:15:00.000+08:00

本文章介紹基本的合併流程, 以Subclipse為例

在要合併的目錄, 可以由 Team --> 列出Subclipse所有功能

假設bdp是trunk project, bdp2是branch project

1.首先將新專案bdp2分支 Trunk > Branch

2.Branch開發到一半, 若要跟Trunk合併, 這時要選擇bdp2(也就是branch的project)按右鍵,
選Team -> 合併 ->
選擇 Merge a range of revisions

3.開發完成後, 要回主線 Trunk < Branch, 這時要選擇bdp(也就是trunk的project)按右鍵,

選Team -> 合併 ->

選擇 Reintegrate a branch

4.選擇要回去的branch的同階目錄(若從WebContent開始合併, 就指到branch的WebContent)

5.每次合併的結果, 可從 Merge Results Tab查看

--
Subclipse圖示的解釋
(圖示出處: http://stackoverflow.com/questions/3917925/what-do-the-arrow-icons-in-subclipse-mean

- A file ignored by version control. You can control what resources will be ignored by going to Window → Preferences → Team → Ignored Resources.
- A file not under version control. These are typically new files that you have not committed to the repository yet.
- A versioned file that needs to be added to the remote repository. These are typically files you have either renamed, or moved to a different directory.
- A deleted folder. These are folders that you have deleted locally without yet committing the changes to the repository. Note that files are usually removed from the view when they're deleted locally, so they are normally not seen with this icon.
- A file with no local changes.
- A file with local, uncommitted changes.
- A locked file.
- A file that needs a lock to be edited. These are typically files that cannot easily be merged (i.e. binary files), but may have many editors. A file needs a lock when its svn:needs-lock property is set, and Subversion will attempt to make these files read-only in the file system to enforce proper lock negotation.
- A conflicted file. These are typically files that had a commit/update conflict that you marked to resolve later.
- A file that has a tree conflict. These are typically files that have local changes, but have since been moved, removed, or renamed in the repository since the last local copy update.
- A file that is external to the project. Linked external files cannot be committed to the repository.
- A file that has been switched. These are files which belongs to a different working copy than their local parent directory.

In a synchronization view (e.g. via Synchronize with Repository or Commit), as previously described, there are icons which indicate which direction a change is occurring in as well as additional information about that change. These are described below:

Outgoing
- A file whose contents have been modified and will be committed to the repository.
- A file that will be newly added to the repository. This may coincide with a file removal in cases where a file is moved or renamed..
- A file that will be removed from the repository. This may coincide with a file addition in cases where a file is moved or renamed.
- A file with property changes, in the Commit dialog. On the Synchronize tab, property changes are currently reflected as a normal file modification ().

在上次commit後, 部份屬性有變動
由合併的目錄, 會記錄合併後相關訊息(svn:mergeinfo)
以trunk合併branch情境來看
假設 trunk/WebContent merge branch/WebContent
原本上次合併是由 100 ~ 120, 目前最新版本是121, 合併後也會記錄一個版本, 所以會變成122, 那麼mergeinfo這檔案就是記錄100 ~ 122版本, 但重點是我們還沒有commit
所以此訊息會提示, 我們上次commit是100 ~ 120, 合併後版本變成 100 ~ 122, 它希望我們能commit這版本
為了要記錄這次合併的版本, 所做的提示(因為我們可能在下一階又commit其他變動)

Incoming
- A file that has content changes committed to the repository that will be applied to the local copy.
- A new file that will be added to the local copy from the repository. Like the outgoing file addition, this may be the result of a move or rename.
- A file that will be removed from the local copy because it has been removed from the repository. Like the outgoing file removal, this may be the result of a move or rename.

Conflict
- A file that has been changed in both the local copy and repository independently, causing a need for conflict resolution. Fixing this condition involves opening up the conflict view or forcibly overwriting changes locally or remotely.

- A file that has a tree conflict. This can occur when there are new changes to a file on one end (either local or remote), and the file is moved, removed, or renamed on the other.

Finally, the Synchronize with Repository option opens the Synchronize tab () with the following buttons:

- Synchronizes the local copy with the currently selected repository when clicked. Selecting from the drop-down allows switching between different remote code bases.
- Shows only incoming changes (remote → local).
- Shows only outgoing changes (local → remote).
- Shows both incoming and outgoing changes (remote ↔ local).
- Shows conflicting changes.
- Updates all local resources with incoming changes after prompt.
- Brings up the commit dialog to commit all outgoing changes.
- Breaks up the change lists by revisions.

--

Conflict
Delete:只要是目錄有變動, 都算是
Add:
Edit:
Local:本機修改
Incoming:是别人修改, 你要Update或Merge進来

Tree Conflict

update情況

Local delete, incoming edit upon update
Local edit, incoming delete upon update
Local delete, incoming delete upon update (二邊都刪掉, 直接標記解決就行)

merge情況
Local missing, incoming edit upon merge
Local edit, incoming delete upon merge (當trunk合併branch, 若trunk修改此檔案, 但trunk刪除時)
Local add, incoming add upon merge (當branch回trunk, 若truck已有此檔案, 但trunk也新增)

測試:

Local delete, incoming edit upon update

最好是每次合併後, 都檢查一下是否有 Tree Conflict, 因為不是每次都有提示

Criteria

2012-02-22T10:14:00.000+08:00

分頁
@SuppressWarnings("unchecked")
public List listByUserIdAndState(int userId, int state, int first, int size) {

Criteria criteria = ss.createCriteria(User.class);
criteria.add(Restrictions.eq("userId", userId));
criteria.add(Restrictions.eq("state", state));
criteria.setFirstResult(first);
criteria.setMaxResults(size);

return criteria.list();
}

排序

@SuppressWarnings("unchecked")
public List listByUserIdAndState(int userId, int state, int first, int size) {

Criteria criteria = ss.createCriteria(User.class);
criteria.add(Restrictions.eq("userId", userId));
criteria.add(Restrictions.eq("state", state));
criteria.addOrder(Order.desc("updateTime"));
criteria.setFirstResult(first);
criteria.setMaxResults(size);

return criteria.list();
}

使用add()方法加入條件時, 預設是使用and來組合條件, 若要用or

Criteria criteria = ss.createCriteria(User.class);
criteria.add(Restrictions.eq("userId", userId));
criteria.add(Restrictions.or(
Restrictions.eq("state", new Integer(1) ),
Restrictions.isNull("state")
));
return criteria.list();

Like

Criteria criteria = ss.createCriteria(User.class);
criteria.add(Restrictions.eq("userId", userId));
criteria.add(Restrictions.like("phone", "%" + phone + "%"));

return criteria.list();

Restrictions
Restrictions.eq
Restrictions.allEq (參數為map)
Restrictions.gt
Restrictions.ge
Restrictions.lt
Restrictions.le
Restrictions.between
Restrictions.like
Restrictions.in
Restrictions.and
Restrictions.or
Restrictions.isNull
Restrictions.isNotNull
Restrictions.sqlRestriction
Order.asc
Order.descMatchMode.EXACT = "like 'value'"
MatchMode.ANYWHERE = "like '%value%'"
MatchMode.START = like 'value%'"
MatchMode.END = "like '%value'"

Disjunction

Criteria criteria = ss.createCriteria(User.class);
criteria.add(Restrictions.eq("userId", userId));
Criterion phoneCriterion = Restrictions.like("phone", phone, MatchMode.ANYWHERE);
Criterion mobileCriterion = Restrictions.like("mobile", mobile, MatchMode.ANYWHERE);
Disjunction disjunction = Restrictions.disjunction();
disjunction.add(phoneCriterion);
disjunction.add(mobileCriterion);
criteria.add(disjunction);

  return criteria.list();

Count
public int countByUserIdAndState(int userId, int state) {

Criteria criteria = ss.createCriteria(User.class);
criteria.add(Restrictions.eq("userId", userId));
criteria.add(Restrictions.eq("state", state));
  criteria.setProjection(Projections.rowCount());

  return (Integer) criteria.uniqueResult();
}

group by
ProjectionList projectionList = Projections.projectionList();
projectionList.add(Projections.groupProperty("area"), "area");
projectionList.add(Projections.rowCount(), "userId");

Criteria criteria = ss.createCriteria(User.class);
criteria.add(Restrictions.eq("userId", userId));
criteria.setProjection(projectionList);

return criteria.list();

回傳結果
public List<HashMap<String, Integer>> listUser(int userId) {
ProjectionList projectionList = Projections.projectionList();
projectionList.add(Projections.groupProperty("area"), "area");
projectionList.add(Projections.rowCount(), "userId");
Criteria criteria = ss.createCriteria(User.class);
criteria.add(Restrictions.eq("userId", userId));
criteria.setProjection(projectionList);
criteria.setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP);
return criteria.list();
}

Example 用目前的物件查詢

User user = new User();

user.setAge(new Integer(30));

Criteria criteria = session.createCriteria(User.class);

criteria.add(Example.create(user));

List users = criteria.list();

Hibernate: select this_.id as id0_0_, this_.name as name0_0_, this_.age as age0_0_ from T_USER this_ where (this_.age=?)

sqlRestriction - 直接下SQL

Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.sqlRestriction(
"{alias}.name LIKE (?)", "todd%", Hibernate.STRING));
List users = criteria.list();

HQL

String hql = "select * from user";

Query query = session.createQuery(hql);

list = query.list();

jquery 1.3 mouseleave event, trigger select option

2011-10-13T10:50:00.002+08:00

jquery 1.3 mouseleave event, trigger select option

這是bug嗎? 若綁定mouseleave, 底下若有select tag時, 也會多trigger leave

< div class="move_wrp">
    < select>
       < option>
    < /select>
< /div>

解決方式

$j(".move_wrp").mouseleave(function(e){
    if ((typeof e.fromElement != 'undefined' && !e.fromElement.length) ||
        (typeof e.fromElement == 'undefined' && e.target.tagName != 'SELECT')) {
      $j(this).hide();
    }
});

安裝apache, subverion

2010-12-14T11:55:00.001+08:00

安裝Subverion筆記

    目標:
        visualsvn 移機
        再加上修改密碼功能

    環境:
        ubuntu10
        apache2.2
        php5
        Subversion

    1.使用samba mount到 VisualSvn
        mount.cifs //xx.xx.xx.xx/SvnRepository /usr/local/SvnRoot -o user=xxx,pass=xxx

    2.安裝apache2
        sudo apt-get install apache2 apache2-common apache2-utils apache2-doc
        預設裝在
            /etc/apache2/
            /etc/apache2/apache2.conf
        root
            /var/www

    3.安裝subversion
        sudo apt-get install subversion libapache2-svn

    4.設定環境, 使用apache2去管理Subversion

        4.1 文件有提到要使用liunx的group去管理權限 (重要, 才能commit)
            sudo addgroup subversion
            sudo usermod -G subversion -a www-data

            sudo chown -R root:subversion myproject
            sudo chown -R www-data:www-data /var/local/svnroot
            --> 授予 Apache(www-data) 使用者存取的權限

            /etc/group

        4.2 初始化一個repository
            sudo svnadmin create /usr/local/SvnRoot

        4.3 修改dav_svn.conf
            sudo vi /etc/apache2/mods-available/dav_svn.conf
            --> 此路徑底下的文件生效
                DAV svn
                #SVNParentPath /mnt/SvnRepository
                SVNParentPath /usr/local/SvnRoot
                   --> SVNPath指Subversion的檔案庫路徑,SVNParentPath指此路徑底下所有目錄
                   都會是Subversion檔案庫
                AuthType Basic
                AuthName "Agenda eSolution Java Dept Subversion repository"
                AuthUserFile /etc/subversion/passwd
                AuthzSVNAccessFile /etc/subversion/authz
                Require valid-user
                #SVNAutoversioning on


        4.4 Subversion 設定文件路徑 /etc/subversion/
            新增Subversion使用者
                sudo htpasswd /etc/subversion/passwd todd (-c 會砍掉檔案重建)

            新增Subversion權限
                [aliases]
                # joe = /C=XZ/ST=Dessert/L=Snake City/O=Snake Oil, Ltd./OU=
                Research Institute/CN=Joe Average

                [groups]
                testgroup=todd

                [svn:/]
                *=

                [test:/]
                @agenda= rw
                todd2= rw
    5.SSL
        5.1 安裝
            sudo apt-get install ssl-cert

        5.2 Enable the SSL Apache module
            sudo a2enmod ssl

            /etc/apache2/ports.conf
            應該要有

                Listen 443


        5.3 生成一個 SSL證書
            mkdir /etc/apache2/ssl
            sudo /usr/sbin/make-ssl-cert /usr/share/ssl-cert/ssleay.cnf /etc/apache2/ssl/apache.pem

        5.4 修改/etc/apache2/sites-available/default-ssl

            改成產生的路徑
            #SSLCertificateFile    /etc/apache/ssl/apache.pem
            #SSLCertificateKeyFile /etc/ssl/private/ssl-cert-snakeoil.key ?

        5.5 修改/etc/apache2/mods-available/dav_svn.conf

                ...
                SSLRequireSSL --> 加入


        5.6 這一步很重要
            sudo a2ensite default-ssl
            sudo /etc/init.d/apache2 restart

        5.7 根憑證 (Root CA) 作法：
            建立根憑證的 Private Key:
                openssl genrsa -des3 -out RootCA.key 2048
                    密碼請來問我

            產生根憑證的申請書:
                openssl req -new -key RootCA.key -out RootCA.req
                chmod og-rwx RootCA.key

            使用根憑證本身簽髮根憑證:
                openssl x509 -req -days 3650 -sha1 -extensions v3_ca -signkey RootCA.key
                -in RootCA.req -out RootCA.crt

                rm -f RootCA.req
        5.8 伺服器憑證作法：
            建立伺服器憑證的 Private Key:
                openssl genrsa -out HostCA.key 2048

            產生伺服器憑證的申請書
                openssl req -new -key HostCA.key -out HostCA.req
                chmod og-rwx HostCA.key

                tip: 在填申請伺服器憑證申請書時 (Common Name) 要填上主機的全名,
                    不然用client去連subversion時會出現
                    server certificate was missing commonName attribute in subject name的錯誤

            使用根憑證簽發伺服器憑證
                openssl x509 -req -days 365 -sha1 -extensions v3_req -CA RootCA.crt
                -CAkey RootCA.key -CAserial RootCA.srl -CAcreateserial -in HostCA.req
                -out HostCA.crt

                rm -f HostCA.req

        5.9 修改 vi /etc/apache2/sites-available/default-ssl
            SSLCertificateFile    /etc/apache2/ssl/RootCA.crt
            SSLCertificateKeyFile /etc/apache2/ssl/RootCA.key

            tip: 這裡認證的檔案是使用 RootCA的,
                    我之前打了HostCA, 會出現
                    svn: OPTIONS of 'https://xxxx.xxxx.xxxx.xxxx/svn/xxxx':
                    SSL handshake failed: \ SSL error code 01 的錯誤

    6.新增修改帳密的 passwd.php

        5.1.安裝php5
            sudo apt-get install php5
            sudo apt-get install libapache2-mod-php5

        5.2.新增 /var/www/passwd.php

        5.3.修改 /etc/apache2/mods-available/dav_svn.conf, 目的是使用apache來做驗證
            在apache增加一個Alias, 設定該路徑需要認證, 指定認證的文件為 Subversion

            Alias /svntools "/var/www/"

                    Require valid-user
                    # how to authenticate a user
                    AuthType Basic
                    AuthName "Subversion Tools"
                    AuthUserFile /etc/subversion/passwd


        5.4.修改權限
            chmod 777 /etc/subversion/passwd

    最後 restart server時, 會要打上CA憑證的密碼 --> 這裡可以再改成起動時就設, 這部份未處理
    修改 httpd.conf 加入 ServerName xxxx.xxxx.xxxx.xxxx

    7.改成對外
        將原本 VisualSVN Server導到 xx.xx.xx.xx:443

        所以修改 VisualSVN Server\conf\httpd.conf
        7.1 要打開 #LoadModule ssl_module bin/mod_ssl.so

            SSLProxyEngine on
            proxyPass xxx
            ProxyPassReverse xxx

安裝tomcat

2010-12-14T11:46:00.000+08:00

    java
        sudo apt-get install openjdk-6-jdk
        cd /usr/lib/jvm/java-1.6.0-openjdk/

    tomcat
        tar xvzf apache-tomcat-6.0.14.tar.gz
        sudo mv apache-tomcat-6.0.14 /usr/local/tomcat
        vi /etc/init.d/tomcat

        export CATALINA_HOME=/usr/local/tomcat
        export JAVA_HOME=/usr/lib/jvm/java-1.6.0-openjdk
        export PATH=$JAVA_HOME/bin:$PATH

        /usr/local/tomcat/lib/
            jtds-1.2.jar
            proxool-0.9.0RC3.jar
            proxool-0.9.1.jar
            proxool-cglib.jar

        /usr/local/tomcat/conf/content.xml

                factory="org.logicalcobwebs.proxool.ProxoolDataSource"
                name="jdbc/xxx"
                password="xxx"
                proxool.alias="xxx"
                proxool.driver-class="net.sourceforge.jtds.jdbc.Driver"
                proxool.driver-url="jdbc:jtds:sqlserver://xx.xx.xx.xx:1433;databaseName=xxx"
                proxool.prototype-count="4"
                type="javax.sql.DataSource"
                 user="xxx"/>

        目前先copy 到 /usr/local/tomcat/webapps/rbs

        sudo /etc/init.d/tomcat start
        sudo /etc/init.d/tomcat restart

        demo:
            http://xx.xx.xx.xx:8080/xxx/

prototype

2010-10-15T11:53:00.001+08:00

$('xxx').readAttribute('xxx')
$('xxx').writeAttribute('xxx')

$(element).show();
$(element).hide();

$(element).up('div')
$(element).down('div')

$(element).select('div') //指定選tag
$(element).getElementsBySelector('div#xxx') //可以指定id, 或 input[]

$(element).getElementsBySelector('xxx').first() //若回傳是list, 可用 [0], 或 .first() 取element

$(element).each(function (el, index) {
    //
});

$(element).childElements()[0].addClassName('current');
$(element).childElements()[0].removeClassName('current');


$(element).setStyle({'display':'block'});

document.observe("dom:loaded", function() {
    $$("xxx").each( function(element, index){
        element.observe("click",function(pEvent){
            //
        } );
    } );
});

regex 檢查 example

2010-10-01T16:51:00.000+08:00

來源: http://tw.myblog.yahoo.com/davidbulll/article?mid=79&prev=277&next=76

＜form onsubmit="return check();"＞
＜input type="text" name="t1"＞
＜input type="submit"＞
＜/form＞
＜script language="javascript"＞

--------------------------------檢查數字(整數)

function check() {
re = /^\d+$/;
if (!re.test(document.forms[0].t1.value)) {
    alert("欄位不能空白且只允許輸入數字");
    document.forms[0].t1.focus();
    return false;
}
return true;
}

--------------------------------檢查數字可有小數

function check(thisname) {

if (isNaN(document.getElementById(thisname).value)) {
    alert("欄位不能空白且只允許輸入數字");
    document.getElementById(thisname).focus();
    return false;
}
}

--------------------------------檢查是否有填資料

----------------------------------檢查是否為MAIL格式

    re1 = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9])+$/;
if (re1.exec(theForm.email.value) == null)
{
alert("你的電子郵件格式不合！");
    theForm.email.focus();
    return (false);
}
＜/script＞
----------------------------------檢查日期格式

--------------------------------------------------------
＜input name="Submit2" type="submit" value="送出" onclick="return check()"＞

hadoop 範例練習

2010-04-04T02:24:00.000+08:00

我的環境:
cygwin
hadoop-0.20.2

1.安裝cygwin, 與必要套件
...

2.

參考
http://www.ibm.com/developerworks/cn/opensource/os-cn-hadoop1/

其中, 提到以本機來模擬多台server的分散運算的部份
步驟3, 要讓hadoop-site.xml裡設定的各台server, 能以ssh免密碼方式登入
我在gen完key後, ssh localhost, 會出現
ssh connect to host localhost port 22 connection refused

原因是
要啓用 sshd service

參考
http://www.experts-exchange.com/Software/CYGWIN/Q_23631555.html
http://cha.homeip.net/blog/archives/2006/04/_winxp_cygwin_s.html

ssh-host-config , 我都選 yes
它會在 /etc/ 下產生一些ssh檔案
這時再試 ssh localhost應該要可以登入了

補充:
http://changyy.pixnet.net/blog/post/25245658

Hibernate Annotation 對映

2010-01-24T23:39:00.002+08:00

One2OneUnidirectAssociationPk
One2OneUnidirectAssociationJoin
One2OneUnidirectAssociationFk

One2OneBidirectAssociationJoin

One2ManyUnidirectAssociationJoinMember
One2ManyUnidirectAssociationFk

One2ManyAndMany2OneBidirectAssociation
One2ManyAndMany2OneBidirectAssociationJoin

Many2OneUnidirectAssociationJoin
Many2OneUnidirectAssociationFk

Many2ManyUnidirectAssociationJoin
Many2ManyBidirectAssociationJoin

package com.todd;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;

public class HibernateAnnotationHelper {
    private static SessionFactory sessionFactory;
    static {
        try {
            sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();

        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public static void close() {
        getSessionFactory().close();
    }
}

Hibernate Annotation One2OneUnidirectAssociationPk

2010-01-24T23:27:00.000+08:00

Member

package com.todd.bean;

import java.io.Serializable;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;


@Entity
@Table(name = "one2one_unidirect_association_pk_member")
public class One2OneUnidirectAssociationPkMember implements Serializable{

    private String user_id;
    private String user_name;
    private String member_desc;
    
    private One2OneUnidirectAssociationPkSkill skill;
    
    @Id
    @Column(name = "user_id")
    public String getUser_id() {
        return user_id;
    }
    public void setUser_id(String user_id) {
        this.user_id = user_id;
    }

    @Column(name = "user_name")
    public String getUser_name() {
        return user_name;
    }
    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    @Column(name = "member_desc")
    public String getMember_desc() {
        return member_desc;
    }
    public void setMember_desc(String member_desc) {
        this.member_desc = member_desc;
    }
    
    @OneToOne
    @PrimaryKeyJoinColumn
    public One2OneUnidirectAssociationPkSkill getSkill() {
        return skill;
    }
    public void setSkill(One2OneUnidirectAssociationPkSkill skill) {
        this.skill = skill;
    }


}

Skill

package com.todd.bean;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;


@Entity
@Table(name = "one2one_unidirect_association_pk_skill")
public class One2OneUnidirectAssociationPkSkill implements Serializable{

    private String user_id;
    private String skill;
    
    @Id
    @Column(name = "user_id")
    public String getUser_id() {
        return user_id;
    }
    public void setUser_id(String user_id) {
        this.user_id = user_id;
    }
    
    @Column(name = "skill")
    public String getSkill() {
        return skill;
    }
    public void setSkill(String skill) {
        this.skill = skill;
    }
    

    
}

Test

package com.todd.bean;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;

import junit.framework.TestCase;

import com.todd.HibernateAnnotationHelper;

/**
 * 1.讓主鍵對映就行
 * @author Todd
 */
public class One2OneUnidirectAssociationPkMyTestCaseA extends TestCase {


    public void test(){
        
        Session session = HibernateAnnotationHelper.getSessionFactory().openSession();        
        Transaction tx = session.beginTransaction();

        One2OneUnidirectAssociationPkMember member = new One2OneUnidirectAssociationPkMember();
        member.setUser_id("ots520");
        member.setUser_name("ots520");
        member.setMember_desc("ots520 desc");
        
        One2OneUnidirectAssociationPkSkill skill = new One2OneUnidirectAssociationPkSkill();
        skill.setUser_id("ots520");
        skill.setSkill("ass");
        member.setSkill(skill);
        
        session.save(member);
        session.save(skill);
        
        One2OneUnidirectAssociationPkMember pkMember = (One2OneUnidirectAssociationPkMember) session.get(One2OneUnidirectAssociationPkMember.class, "ots520");
        System.out.println("member desc =" + pkMember.getMember_desc());
        
        
        tx.commit();
        session.close();        
        
    }
    


}

Hibernate Annotation One2OneUnidirectAssociationJoin

2010-01-24T23:26:00.000+08:00

Member

package com.todd.bean;

import java.io.Serializable;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;


@Entity
@Table(name = "one2one_unidirect_association_join_member")
public class One2OneUnidirectAssociationJoinMember implements Serializable{

    private int member_id;
    private String user_id;
    private String user_name;
    private String member_desc;
    
    private One2OneUnidirectAssociationJoinSkill skill;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "member_id")    
    public int getMember_id() {
        return member_id;
    }
    public void setMember_id(int member_id) {
        this.member_id = member_id;
    }
    
    @Column(name = "user_id")
    public String getUser_id() {
        return user_id;
    }
    public void setUser_id(String user_id) {
        this.user_id = user_id;
    }

    @Column(name = "user_name")
    public String getUser_name() {
        return user_name;
    }
    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    
    @Column(name = "member_desc")
    public String getMember_desc() {
        return member_desc;
    }
    public void setMember_desc(String member_desc) {
        this.member_desc = member_desc;
    }

    
    @OneToOne(optional = true)
    @JoinTable(name = "one2one_unidirect_association_join_member_skill", 
            joinColumns = { 
                @JoinColumn(name = "fk_member_id", unique = true) 
            }, 
            inverseJoinColumns = { 
                @JoinColumn(name = "fk_skill_id") 
            }
        )
    public One2OneUnidirectAssociationJoinSkill getSkill() {
        return skill;
    }
    public void setSkill(One2OneUnidirectAssociationJoinSkill skill) {
        this.skill = skill;
    }

}

Skill

package com.todd.bean;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;


@Entity
@Table(name = "one2one_unidirect_association_join_skill")
public class One2OneUnidirectAssociationJoinSkill implements Serializable{

    private int skill_id;
    private String user_id;
    private String skill;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "skill_id")    
    public int getSkill_id() {
        return skill_id;
    }
    public void setSkill_id(int skill_id) {
        this.skill_id = skill_id;
    }

    
    
    @Column(name = "user_id")
    public String getUser_id() {
        return user_id;
    }
    public void setUser_id(String user_id) {
        this.user_id = user_id;
    }
    
    @Column(name = "skill")
    public String getSkill() {
        return skill;
    }
    public void setSkill(String skill) {
        this.skill = skill;
    }


    
}

Test

package com.todd.bean;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;

import junit.framework.TestCase;

import com.todd.HibernateAnnotationHelper;

/**
* 1.join 的仲介table, 不需有實體bean, 會自己產生
* 2.
* @author Todd
*/
public class One2OneUnidirectAssociationJoinMyTestCaseA extends TestCase {

    public void test(){

        Session session = HibernateAnnotationHelper.getSessionFactory().openSession();
        Transaction tx = session.beginTransaction();

        One2OneUnidirectAssociationJoinMember member = new One2OneUnidirectAssociationJoinMember();
        member.setUser_id("ots520");
        member.setUser_name("ots520");
        member.setMember_desc("ots520 desc");

        One2OneUnidirectAssociationJoinSkill skill = new One2OneUnidirectAssociationJoinSkill();
        skill.setUser_id("ots520");
        skill.setSkill("ass");
        member.setSkill(skill);

        session.save(member);
        session.save(skill);

        One2OneUnidirectAssociationJoinMember JoinMember = (One2OneUnidirectAssociationJoinMember) session.get(One2OneUnidirectAssociationJoinMember.class, 1);
        System.out.println("member desc =" + JoinMember.getMember_desc());


        tx.commit();
        session.close();

    }


}

Hibernate Annotation One2OneUnidirectAssociationFk

2010-01-24T23:22:00.000+08:00

Member

package com.todd.bean;

import java.io.Serializable;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;

@Entity
@Table(name = "one2one_unidirect_association_fk_member")
public class One2OneUnidirectAssociationFkMember implements Serializable{

    private int oid;
    private String user_id;
    private String user_name;
    private String member_desc;
    
    private One2OneUnidirectAssociationFkSkill skill;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "oid")
    public int getOid() {
        return oid;
    }
    public void setOid(int oid) {
        this.oid = oid;
    }
    
    @Column(name = "user_id")
    public String getUser_id() {
        return user_id;
    }
    public void setUser_id(String user_id) {
        this.user_id = user_id;
    }

    @Column(name = "user_name")
    public String getUser_name() {
        return user_name;
    }
    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    @Column(name = "member_desc")
    public String getMember_desc() {
        return member_desc;
    }
    public void setMember_desc(String member_desc) {
        this.member_desc = member_desc;
    }
    
    @OneToOne
    @JoinColumn(name = "skill_id")
    public One2OneUnidirectAssociationFkSkill getSkill() {
        return skill;
    }
    public void setSkill(One2OneUnidirectAssociationFkSkill skill) {
        this.skill = skill;
    }


}

Skill

package com.todd.bean;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;


@Entity
@Table(name = "one2one_unidirect_association_fk_skill")
public class One2OneUnidirectAssociationFkSkill implements Serializable{

    private int skill_id;
    private String user_id;
    private String skill;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "skill_id")    
    public int getSkill_id() {
        return skill_id;
    }
    public void setSkill_id(int skill_id) {
        this.skill_id = skill_id;
    }
    
    @Column(name = "user_id")
    public String getUser_id() {
        return user_id;
    }
    public void setUser_id(String user_id) {
        this.user_id = user_id;
    }
    
    @Column(name = "skill")
    public String getSkill() {
        return skill;
    }
    public void setSkill(String skill) {
        this.skill = skill;
    }

}

Test

package com.todd.bean;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;

import junit.framework.TestCase;

import com.todd.HibernateAnnotationHelper;


public class One2OneUnidirectAssociationFkMyTestCaseA extends TestCase {


    public void test(){
        
        Session session = HibernateAnnotationHelper.getSessionFactory().openSession();        
        Transaction tx = session.beginTransaction();

        One2OneUnidirectAssociationFkMember member = new One2OneUnidirectAssociationFkMember();
        member.setUser_id("ots520");
        member.setUser_name("ots520");
        member.setMember_desc("ots520 desc");
        
        One2OneUnidirectAssociationFkSkill skill = new One2OneUnidirectAssociationFkSkill();
        skill.setUser_id("ots520");
        skill.setSkill("ots520 fk skill");
        member.setSkill(skill);

        session.save(skill);
        session.save(member);

        
        One2OneUnidirectAssociationFkMember TestMember = (One2OneUnidirectAssociationFkMember) session.get(One2OneUnidirectAssociationFkMember.class, 2);
        One2OneUnidirectAssociationFkSkill unidirectAssociationFkSkill = TestMember.getSkill();
        System.out.println("unidirectAssociationFkSkill=" + unidirectAssociationFkSkill.getSkill());
        
        tx.commit();
        session.close();        
        
    }
    


}

Hibernate Annotation One2OneBidirectAssociationJoin

2010-01-24T23:12:00.000+08:00

Member

package com.todd.bean;

import java.io.Serializable;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;



@Entity
@Table(name = "one2one_bidirect_association_join_member")
public class One2OneBidirectAssociationJoinMember implements Serializable{

    private int member_id;
    private String user_id;
    private String user_name;
    private String member_desc;
    
    private One2OneBidirectAssociationJoinSkill skill;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "member_id")    
    public int getMember_id() {
        return member_id;
    }
    public void setMember_id(int member_id) {
        this.member_id = member_id;
    }
    
    @Column(name = "user_id")
    public String getUser_id() {
        return user_id;
    }
    public void setUser_id(String user_id) {
        this.user_id = user_id;
    }

    @Column(name = "user_name")
    public String getUser_name() {
        return user_name;
    }
    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    
    @Column(name = "member_desc")
    public String getMember_desc() {
        return member_desc;
    }
    public void setMember_desc(String member_desc) {
        this.member_desc = member_desc;
    }

    
    @OneToOne(optional = true)
    @JoinTable(name = "one2one_bidirect_association_join_member_skill", 
            joinColumns = { 
                @JoinColumn(name = "fk_member_id", unique = true) 
            }, 
            inverseJoinColumns = { 
                @JoinColumn(name = "fk_skill_id") 
            }
        )
    public One2OneBidirectAssociationJoinSkill getSkill() {
        return skill;
    }
    public void setSkill(One2OneBidirectAssociationJoinSkill skill) {
        this.skill = skill;
    }

}

Skill

package com.todd.bean;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToOne;
import javax.persistence.Table;



@Entity
@Table(name = "one2one_bidirect_association_join_skill")
public class One2OneBidirectAssociationJoinSkill implements Serializable{

    private int skill_id;
    private String user_id;
    private String skill;
    
    private One2OneBidirectAssociationJoinMember member;   
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "skill_id")    
    public int getSkill_id() {
        return skill_id;
    }
    public void setSkill_id(int skill_id) {
        this.skill_id = skill_id;
    }

    
    
    @Column(name = "user_id")
    public String getUser_id() {
        return user_id;
    }
    public void setUser_id(String user_id) {
        this.user_id = user_id;
    }
    
    @Column(name = "skill")
    public String getSkill() {
        return skill;
    }
    public void setSkill(String skill) {
        this.skill = skill;
    }
    
    @OneToOne(optional=true, mappedBy="skill") // pointing to Member's skill field
    public One2OneBidirectAssociationJoinMember getMember() {
        return member;
    }
    public void setMember(One2OneBidirectAssociationJoinMember member) {
        this.member = member;
    }

}

Test

package com.todd.bean;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;

import junit.framework.TestCase;

import com.todd.HibernateAnnotationHelper;

/**
 * 1.join 的仲介table, 不需有實體bean, 會自己產生
 * 2.
 * @author Todd
 */
public class One2OneBidirectAssociationJoinMyTestCaseA extends TestCase {


    public void test(){
        
        Session session = HibernateAnnotationHelper.getSessionFactory().openSession();        
        Transaction tx = session.beginTransaction();

        One2OneBidirectAssociationJoinMember member = new One2OneBidirectAssociationJoinMember();
        member.setUser_id("ots520");
        member.setUser_name("ots520");
        member.setMember_desc("ots520 member desc");
        
        One2OneBidirectAssociationJoinSkill skill = new One2OneBidirectAssociationJoinSkill();
        skill.setUser_id("ots520");
        skill.setSkill("ass");
        member.setSkill(skill);
        skill.setMember(member);
        
        session.save(member);
        session.save(skill);
        
        One2OneBidirectAssociationJoinMember JoinMember = (One2OneBidirectAssociationJoinMember) session.get(One2OneBidirectAssociationJoinMember.class, 1);
        System.out.println("member desc =" + JoinMember.getSkill().getSkill_id());
        
        
        One2OneBidirectAssociationJoinSkill JoinSkill = (One2OneBidirectAssociationJoinSkill) session.get(One2OneBidirectAssociationJoinSkill.class, 1);
        System.out.println("member desc =" + JoinSkill.getMember().getMember_desc());
        
        tx.commit();
        session.close();        
        
    }
    
}

Hibernate Annotation One2ManyUnidirectAssociationJoin

2010-01-24T23:08:00.000+08:00

Member

package com.todd.bean;

import java.io.Serializable;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToMany;
import javax.persistence.Table;


@Entity
@Table(name = "one2many_unidirect_association_join_member")
public class One2ManyUnidirectAssociationJoinMember implements Serializable{

    private int member_id;
    private String user_id;
    private String user_name;
    private String member_desc;

    private List skillList;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "member_id")    
    public int getMember_id() {
        return member_id;
    }
    public void setMember_id(int member_id) {
        this.member_id = member_id;
    }
    
    @Column(name = "user_id")
    public String getUser_id() {
        return user_id;
    }
    public void setUser_id(String user_id) {
        this.user_id = user_id;
    }

    @Column(name = "user_name")
    public String getUser_name() {
        return user_name;
    }
    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    
    @Column(name = "member_desc")
    public String getMember_desc() {
        return member_desc;
    }
    public void setMember_desc(String member_desc) {
        this.member_desc = member_desc;
    }

    
    @OneToMany
    @JoinTable(name = "one2many_unidirect_association_join_member_skill",
        joinColumns = {
            //@JoinColumn(name="fk_member_id", unique = true) //錯的           
            @JoinColumn(name="fk_member_id") 
        },
        inverseJoinColumns = {
            @JoinColumn(name="fk_skill_id")
        }
    )
    public List getSkillList() {
        return skillList;
    }
    public void setSkillList(List skillList) {
        this.skillList = skillList;
    }

}

Skill

package com.todd.bean;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;


@Entity
@Table(name = "one2many_unidirect_association_join_skill")
public class One2ManyUnidirectAssociationJoinSkill implements Serializable{

    private int skill_id;
    private String user_id;
    private String skill;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "skill_id")    
    public int getSkill_id() {
        return skill_id;
    }
    public void setSkill_id(int skill_id) {
        this.skill_id = skill_id;
    }
    
    @Column(name = "user_id")
    public String getUser_id() {
        return user_id;
    }
    public void setUser_id(String user_id) {
        this.user_id = user_id;
    }
    
    @Column(name = "skill")
    public String getSkill() {
        return skill;
    }
    public void setSkill(String skill) {
        this.skill = skill;
    }


    
}

Test

package com.todd.bean;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;

import junit.framework.TestCase;

import com.todd.HibernateAnnotationHelper;

/**
 * 1.
 * 2.
 * @author Todd
 */
public class One2ManyUnidirectAssociationJoinMyTestCaseA extends TestCase {


    public void test(){
        
        Session session = HibernateAnnotationHelper.getSessionFactory().openSession();        
        Transaction tx = session.beginTransaction();

        One2ManyUnidirectAssociationJoinMember member = new One2ManyUnidirectAssociationJoinMember();
        member.setUser_id("ots520");
        member.setUser_name("ots520");
        member.setMember_desc("ots520 desc");
        
        List skillList = new ArrayList();
        One2ManyUnidirectAssociationJoinSkill skill1 = new One2ManyUnidirectAssociationJoinSkill();
        skill1.setUser_id("ots520");
        skill1.setSkill("ass1");
        session.save(skill1);
        skillList.add(skill1);
        
        One2ManyUnidirectAssociationJoinSkill skill2 = new One2ManyUnidirectAssociationJoinSkill();
        skill2.setUser_id("ots5202");
        skill2.setSkill("ass2");
        session.save(skill2);
        skillList.add(skill2);
        
        member.setSkillList(skillList);
        session.save(member);

        
        
        
        One2ManyUnidirectAssociationJoinMember JoinMember = (One2ManyUnidirectAssociationJoinMember) session.get(One2ManyUnidirectAssociationJoinMember.class, 3);
        if(!(JoinMember == null)){
            List list = JoinMember.getSkillList();
            for (One2ManyUnidirectAssociationJoinSkill one2ManyUnidirectAssociationJoinSkill : list) {
                System.out.println("one2ManyUnidirectAssociationJoinSkill=" + one2ManyUnidirectAssociationJoinSkill.getSkill_id());
            }
        }
        
        
        
        tx.commit();
        session.close();        
        
    }
    


}

Hibernate Annotation One2ManyUnidirectAssociationFk

2010-01-24T23:07:00.000+08:00

Member

package com.todd.bean;

import java.io.Serializable;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;


@Entity
@Table(name = "one2many_unidirect_association_fk_member")
public class One2ManyUnidirectAssociationFkMember implements Serializable{

    private int memberId;
    private String userId;
    private String userName;
    private String memberDesc;

    private List skillList;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "member_id")    
    public int getMemberId() {
        return memberId;
    }
    public void setMemberId(int memberId) {
        this.memberId = memberId;
    }
    
    @Column(name = "user_id")
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    
    @Column(name = "user_name")
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    
    @Column(name = "member_desc")
    public String getMemberDesc() {
        return memberDesc;
    }
    public void setMemberDesc(String memberDesc) {
        this.memberDesc = memberDesc;
    }
    
    @OneToMany
    @JoinColumn(name = "member_id") // watch out!
    public List getSkillList() {
        return skillList;
    }
    public void setSkillList(List skillList) {
        this.skillList = skillList;
    }
    

}

Skill

package com.todd.bean;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;


@Entity
@Table(name = "one2many_unidirect_association_fk_skill")
public class One2ManyUnidirectAssociationFkSkill implements Serializable{

    private int skillId;
    private String userId;
    private String skill;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "skill_id")    
    public int getSkillId() {
        return skillId;
    }
    public void setSkillId(int skillId) {
        this.skillId = skillId;
    }
    
    @Column(name = "user_id")
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }

    @Column(name = "skill")
    public String getSkill() {
        return skill;
    }
    public void setSkill(String skill) {
        this.skill = skill;
    }
    
}

Test

package com.todd.bean;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;

import junit.framework.TestCase;

import com.todd.HibernateAnnotationHelper;

/**
 * 1.
 * 2.
 * @author Todd
 */
public class One2ManyUnidirectAssociationFkMyTestCaseA extends TestCase {


    public void test(){
        
        Session session = HibernateAnnotationHelper.getSessionFactory().openSession();        
        Transaction tx = session.beginTransaction();

        One2ManyUnidirectAssociationFkMember member = new One2ManyUnidirectAssociationFkMember();
        member.setUserId("ots520");
        member.setUserName("ots520");
        member.setMemberDesc("ots520 desc");
        
        List skillList = new ArrayList();
        One2ManyUnidirectAssociationFkSkill skill1 = new One2ManyUnidirectAssociationFkSkill();
        skill1.setUserId("ots520");
        skill1.setSkill("skill1");
        session.save(skill1);
        skillList.add(skill1);
        
        One2ManyUnidirectAssociationFkSkill skill2 = new One2ManyUnidirectAssociationFkSkill();
        skill2.setUserId("ots520");
        skill2.setSkill("skill2");
        session.save(skill2);
        skillList.add(skill2);

        
        member.setSkillList(skillList);
        session.save(member);

        
        
        
        One2ManyUnidirectAssociationFkMember JoinMember = (One2ManyUnidirectAssociationFkMember) session.get(One2ManyUnidirectAssociationFkMember.class, 1);
        if(!(JoinMember == null)){
            List list = JoinMember.getSkillList();
            for (One2ManyUnidirectAssociationFkSkill one2ManyUnidirectAssociationFkSkill : list) {
                System.out.println("one2ManyUnidirectAssociationFkSkill=" + one2ManyUnidirectAssociationFkSkill.getSkillId());
            }
        }
        
        
        
        tx.commit();
        session.close();        
        
    }
    


}

Hibernate Annotation One2ManyAndMany2OneBidirectAssociation

2010-01-24T23:03:00.000+08:00

Member

package com.todd.bean;

import java.io.Serializable;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;


@Entity
@Table(name = "one2many_and_many2one_bidirect_association_member")
public class One2ManyAndMany2OneBidirectAssociationMember implements Serializable{

    private int memberId;
    private String userId;
    private String userName;
    private String memberDesc;

    private List skillList;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "member_id")        
    public int getMemberId() {
        return memberId;
    }
    public void setMemberId(int memberId) {
        this.memberId = memberId;
    }
    
    @Column(name = "user_id")
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    
    @Column(name = "user_name")
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    
    @Column(name = "member_desc")
    public String getMemberDesc() {
        return memberDesc;
    }
    public void setMemberDesc(String memberDesc) {
        this.memberDesc = memberDesc;
    }


    @OneToMany(mappedBy="member") // 對應到對方的 field喔 , 不是column name
    @Column(name="skill_id")  // inverse=true
    public List getSkillList() {
        return skillList;
    }
    public void setSkillList(
            List skillList) {
        this.skillList = skillList;
    }


}

Skill

package com.todd.bean;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;


@Entity
@Table(name = "one2many_and_many2one_bidirect_association_skill")
public class One2ManyAndMany2OneBidirectAssociationSkill implements Serializable{

    private int skillId;
    private String userId;
    private String skill;
    
    private One2ManyAndMany2OneBidirectAssociationMember member;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "skill_id")    
    public int getSkillId() {
        return skillId;
    }
    public void setSkillId(int skillId) {
        this.skillId = skillId;
    }
    
    @Column(name = "user_id")
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    
    @Column(name = "skill")
    public String getSkill() {
        return skill;
    }
    public void setSkill(String skill) {
        this.skill = skill;
    }

    @ManyToOne  
    @JoinColumn(name="member_id") // inverse = false , 對應到對方的 id column name
    public One2ManyAndMany2OneBidirectAssociationMember getMember() {
        return member;
    }
    public void setMember(One2ManyAndMany2OneBidirectAssociationMember member) {
        this.member = member;
    }



    
}

Test

package com.todd.bean;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;

import junit.framework.TestCase;

import com.todd.HibernateAnnotationHelper;

/**
 * 1.雙向的話, 只要把One2Many 或 Many2One 對調就行
 * 2.
 * @author Todd
 */
public class One2ManyAndMany2OneBidirectAssociationMyTestCaseA extends TestCase {


    public void test(){
        
        Session session = HibernateAnnotationHelper.getSessionFactory().openSession();        
        Transaction tx = session.beginTransaction();

        One2ManyAndMany2OneBidirectAssociationMember member = new One2ManyAndMany2OneBidirectAssociationMember();
        member.setUserId("ots520");
        member.setUserName("ots520");
        member.setMemberDesc("ots520 desc");
        
        List skillList = new ArrayList();
        One2ManyAndMany2OneBidirectAssociationSkill skill1 = new One2ManyAndMany2OneBidirectAssociationSkill();
        skill1.setUserId("ots520");
        skill1.setSkill("ass1");
        skill1.setMember(member);
        session.save(skill1);
        skillList.add(skill1);
        
        One2ManyAndMany2OneBidirectAssociationSkill skill2 = new One2ManyAndMany2OneBidirectAssociationSkill();
        skill2.setUserId("ots520");
        skill2.setSkill("ass2");
        skill2.setMember(member);
        session.save(skill2);
        skillList.add(skill2);
        
        member.setSkillList(skillList);
        session.save(member);

        
        
        
        One2ManyAndMany2OneBidirectAssociationMember JoinMember = (One2ManyAndMany2OneBidirectAssociationMember) session.get(One2ManyAndMany2OneBidirectAssociationMember.class, 1);
        if(!(JoinMember == null)){
            List list = JoinMember.getSkillList();
            for (One2ManyAndMany2OneBidirectAssociationSkill one2ManyAndMany2OneBidirectAssociationSkill : list) {
                System.out.println("one2ManyAndMany2OneBidirectAssociationSkill=" + one2ManyAndMany2OneBidirectAssociationSkill.getSkillId());
            }
        }
        
        One2ManyAndMany2OneBidirectAssociationSkill JoinSkill = (One2ManyAndMany2OneBidirectAssociationSkill) session.get(One2ManyAndMany2OneBidirectAssociationSkill.class, 4);
        if(!(JoinSkill == null)){
            One2ManyAndMany2OneBidirectAssociationMember JoinSkillMember = JoinSkill.getMember();
            System.out.println("JoinSkillMember=" + JoinSkillMember.getMemberId());
        }
        
        tx.commit();
        session.close();        
        
    }
    


}

Hibernate Annotation One2ManyAndMany2OneBidirectAssociationJoin

2010-01-24T23:01:00.000+08:00

Member

package com.todd.bean;

import java.io.Serializable;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;


@Entity
@Table(name = "one2many_and_many2one_bidirect_association_join_member")
public class One2ManyAndMany2OneBidirectAssociationJoinMember implements Serializable{

    private int memberId;
    private String userId;
    private String userName;
    private String memberDesc;

    private List skillList;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "member_id")        
    public int getMemberId() {
        return memberId;
    }
    public void setMemberId(int memberId) {
        this.memberId = memberId;
    }
    
    @Column(name = "user_id")
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    
    @Column(name = "user_name")
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    
    @Column(name = "member_desc")
    public String getMemberDesc() {
        return memberDesc;
    }
    public void setMemberDesc(String memberDesc) {
        this.memberDesc = memberDesc;
    }
    
    
    
//    @OneToMany
//    @JoinTable(name = "one2many_and_many2one_bidirect_association_join_member_skill",
//        joinColumns = {
//            //@JoinColumn(name="fk_member_id", unique = true) //若要 1 對 1的話, 加上 unique
//            @JoinColumn(name="fk_member_id")         
//        },
//        inverseJoinColumns = {
//            @JoinColumn(name="fk_skill_id")
//        }
//    )
    
    @OneToMany(mappedBy = "member")
    public List getSkillList() {
        return skillList;
    }
    public void setSkillList(
            List skillList) {
        this.skillList = skillList;
    }

}

Skill

package com.todd.bean;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToOne;
import javax.persistence.Table;


@Entity
@Table(name = "one2many_and_many2one_bidirect_association_join_skill")
public class One2ManyAndMany2OneBidirectAssociationJoinSkill implements Serializable{

    private int skillId;
    private String userId;
    private String skill;
    
    private One2ManyAndMany2OneBidirectAssociationJoinMember member;
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "skill_id")    
    public int getSkillId() {
        return skillId;
    }
    public void setSkillId(int skillId) {
        this.skillId = skillId;
    }
    
    @Column(name = "user_id")
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    
    @Column(name = "skill")
    public String getSkill() {
        return skill;
    }
    public void setSkill(String skill) {
        this.skill = skill;
    }
    

    @ManyToOne(optional=true)
    @JoinTable(name = "one2many_and_many2one_bidirect_association_join_member_skill",
        joinColumns = {
          @JoinColumn(name="fk_skill_id", unique = true)
        },
        inverseJoinColumns = {
          @JoinColumn(name="fk_member_id")
        }
    )
    public One2ManyAndMany2OneBidirectAssociationJoinMember getMember() {
        return member;
    }
    public void setMember(One2ManyAndMany2OneBidirectAssociationJoinMember member) {
        this.member = member;
    }
    
}

Test

package com.todd.bean;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;

import junit.framework.TestCase;

import com.todd.HibernateAnnotationHelper;

/**
 * 1.雙向的話, 只要把One2Many 或 Many2One 對調就行
 * 2.
 * @author Todd
 */
public class One2ManyAndMany2OneBidirectAssociationJoinMyTestCaseA extends TestCase {


    public void test(){
        
        Session session = HibernateAnnotationHelper.getSessionFactory().openSession();        
        Transaction tx = session.beginTransaction();

        One2ManyAndMany2OneBidirectAssociationJoinMember member = new One2ManyAndMany2OneBidirectAssociationJoinMember();
        member.setUserId("ots520");
        member.setUserName("ots520");
        member.setMemberDesc("ots520 desc");
        
        List skillList = new ArrayList();
        
        One2ManyAndMany2OneBidirectAssociationJoinSkill skill1 = new One2ManyAndMany2OneBidirectAssociationJoinSkill();
        skill1.setUserId("ots520");
        skill1.setSkill("skill1");
        skill1.setMember(member);
        session.save(skill1);
        skillList.add(skill1);
        
        One2ManyAndMany2OneBidirectAssociationJoinSkill skill2 = new One2ManyAndMany2OneBidirectAssociationJoinSkill();
        skill2.setUserId("ots520");
        skill2.setSkill("skill2");
        skill2.setMember(member);
        session.save(skill2);
        skillList.add(skill2);

        
        member.setSkillList(skillList);
        session.save(member);

        
        
        
        One2ManyAndMany2OneBidirectAssociationJoinMember JoinMember = (One2ManyAndMany2OneBidirectAssociationJoinMember) session.get(One2ManyAndMany2OneBidirectAssociationJoinMember.class, 3);
        if(!(JoinMember == null)){
            List list = JoinMember.getSkillList();
            for (One2ManyAndMany2OneBidirectAssociationJoinSkill one2ManyAndMany2OneBidirectAssociationJoinSkill : list) {
                System.out.println("one2ManyAndMany2OneBidirectAssociationJoinSkill=" + one2ManyAndMany2OneBidirectAssociationJoinSkill.getSkillId());
            }
        }
        
        One2ManyAndMany2OneBidirectAssociationJoinSkill JoinSkill = (One2ManyAndMany2OneBidirectAssociationJoinSkill) session.get(One2ManyAndMany2OneBidirectAssociationJoinSkill.class, 4);
        if(!(JoinSkill == null)){
            One2ManyAndMany2OneBidirectAssociationJoinMember JoinSkillMember = JoinSkill.getMember();
            System.out.println("JoinSkillMember=" + JoinSkillMember.getMemberId());
        }
        
        tx.commit();
        session.close();        
        
    }

}