Listing 1 shows the configuration of the JMS template used for the example application.
(리스팅 1은 설정파일을 보여준다. JMS 템블릿의 예제로 사용되어진)

The listing is an extract from the spring-mqseries-jms.xml file (see Download).
(리스팅은 발췌했다 spring-mqseries-jms.xml 파일에서~)

jms template 설정파일은 아래와 같다!

Listing 1. JMS template configuration

              
  <!-- JMS Queue Template -->
  <bean id="jmsQueueTemplate" 
          class="org.springframework.jms.core.JmsTemplate102">
    <property name="connectionFactory">
      <ref bean="jmsQueueConnectionFactory"/>
    </property>
    <property name="destinationResolver">
      <ref bean="jmsDestinationResolver"/>
    </property>
    <property name="pubSubDomain">
      <value>false</value>
    </property>
    <property name="receiveTimeout">
      <value>20000</value>
    </property>
  </bean>

The jmsQueueTemplate bean is wired with a JMS connection factory and a JMS destination resolver for resolving destination queue names supplied by JMS clients through JNDI. The connectionFactory property specifies how to get a connection to a JMS provider. In the case of the example, Listing 2 shows how to retrieve the connection factory from JNDI.

이 방법이 내가 썼던 방법이다. JNDI : Java Naming Directory Interface

 <!-- JMS Queue Connection Factory -->
  <bean id="internalJmsQueueConnectionFactory"
          class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiTemplate">
      <ref bean="jndiTemplate"/>
    </property>
    <property name="jndiName">
      <value>MQ_JMS_MANAGER</value>
    </property>
  </bean>

As you can see, the JndiObjectFactoryBean is wired to an internalJmsQueueConnectionFactory. The JndiObjectFactoryBean uses the JndiTemplate property for JNDI lookup. Spring will look up the connection factory in JNDI using the environment property and initial context specified in the JndiTemplate. Listing 3 shows the configuration of the JndiTemplate configuration bean.

웁쓰~ 내가 썼던 방법이다..Listing2 에서 Listing 3으로 이어진다..wow~



위의 초록색 부분 처럼 스프링은 찾는다. 커넥션 팩토리를 JNDI안에서 환경 속성과 JndiTemplate의



명시된 초기 컨텍스트에서! 스프링은 찾는다~~~!!! JNDI or JndiTemplate Context에서..



커넥션 팩토리를^^                

The above configuration specifies the initial context factory as com.sun.jndi.fscontext.RefFSContextFactory and the provider URL as the file-based file:/C:/JNDI-Directory for JNDI lookup. For the purpose of the example application,
the JNDI access will use the file-based FSContext version (see Resources) configured for binding MQ queues to JNDI.

더 많은 내용은~참고자료!
http://www.ibm.com/developerworks/java/library/wa-spring4/index.html

참고!! Jms Template API(Spring 3.0.x)
http://static.springsource.org/spring/docs/3.0.x/api/org/springframework/jms/core/JmsTemplate.html

조금 더 detail 한 내용은 회사에 가서 소스와 함께 알아봐야겠다!!

일단 -끝-

요런것들이 필요하다~~라고 되어있었지만..현재 프로젝트는 메이븐 프로젝트였다..

다시 찾아봤더니..아래에 좋은 사이트를 발견하였다^^

외국인 친구 땡큐!

펌] http://www.future-edge.nl/blog/hornetq-jms-client-using-spring-and-maven/

I’ve just been working getting working in our project. We are using Spring and Maven.

Here is an example to get it working:

Maven dependency configuration:

    <!-- JMS -->
    <dependency>
        <groupId>javax.jms</groupId>
        <artifactId>jms-api</artifactId>
        <version>1.1-rev-1</version>
    </dependency>

    <!-- HornetQ -->
    <dependency>  		
        <groupId>org.hornetq</groupId>
        <artifactId>hornetq-core-client</artifactId>
        <version>2.2.18.Final</version>
    </dependency>
    <dependency>
        <groupId>org.hornetq</groupId>
        <artifactId>hornetq-jms-client</artifactId>
        <version>2.2.18.Final</version>
    </dependency>
    <dependency>  
        <groupId>org.jboss.netty</groupId>  
        <artifactId>netty</artifactId>  
        <version>3.2.7.Final</version>
    </dependency>  	

Note you *DON’T* need the hornetq-transports dependency. There is a lot of old ‘help’ with only seems to work using version 2.0.0.GA with did use that JAR.

Spring configuration:

    <bean name="qConnectionFactory" class="org.hornetq.jms.client.HornetQXAConnectionFactory" >
    <constructor-arg value="false" />
     <constructor-arg>
        <bean name="transportConfiguration" class="org.hornetq.api.core.TransportConfiguration">
            <constructor-arg value="org.hornetq.core.remoting.impl.netty.NettyConnectorFactory" />
            <constructor-arg>
                <map key-type="java.lang.String" value-type="java.lang.Object">
                    <entry key="host" value="127.0.0.1" />
                    <entry key="port" value="5445" />
                </map>
            </constructor-arg>
        </bean>
     </constructor-arg>
    </bean>
    
    <bean name="theQueue" class="org.hornetq.jms.client.HornetQQueue">
       <constructor-arg value="someName" />
    </bean>
    
    <bean name="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="qConnectionFactory" />
        <property name="defaultDestinationName" value="theQueue" />
    </bean>    

Note the class used to configure the netty connector factory. That’s what is different between the 2.2.18 version (it’s in the core now) and the 2.0.0.

@XMLAccessorType, @XMLRootElement에 대해서 알아보자!^-^good~

아래를 읽기전에  JAXB?? 이거 모르시는 분은 아래 링크 꾹~~^-^good~!

더보기

JAXB(Java Architecture for XML Binding)는 자바 클래스를 XML로 표현하는 자바 API이다. JAXB는 주로 2가지 기능이 있다. 자바 객체를 XML로 직렬화하는 것이고 반대로 XML에서 자바 객체로 역직렬화하는 것이다. 즉, JAXB는 메모리의 데이터를 XML 형식으로 변환하여 저장할 수 있고, 이 과정을 위해 프로그램의 각 클래스에서 XML을 읽고 저장하는 일을 구현해야 한다.

위키백과 : http://ko.wikipedia.org/wiki/JAXB

@XMLAccessorType                    

더보기

javax.xml.bind.annotation.XmlAccessorType

@Target(value={PACKAGE, TYPE})
@Retention(value=RUNTIME)
@Inherited

Controls whether fields or Javabean properties are serialized by default.
위의 문구가 가장 중요한 문구이다! serialized는 해석을 직렬화라고 해보면.. 
JAXB쪽 위키백과에 나왔듯이 직렬화는 자바 객체를 XML로~!! 이다.

요정도를 베이스로 알고 보면 한결 이해가 높아질 것이다.^-^goood~
사용 할 때 @XmlAccessorType(XmlAccessType까지 쓰고 .(dot)을 누르면
이클립스에서 자동완성 기능이 발동 한다.

그중에 FIELD를 보면 아래와 같다.

더보기

1) Every non static, non transient field(정적이지 않고 일시적인 필드가 없을 때) in a JAXB-bound class
will be automatically bound to XML, unless annotated by XmlTransient.
2) Getter/setter pairs are bound to XML
only when they are explicitly annotated by some of the JAXB annotations.
파란색 부분이 엄청~~~중요하다!
getter/setter 쌍이 xml로 bound된다는 거다!

1) 윗부분을 대~~충 해석해보면 JAXB-bound class인데 정적이지않거나 일시적이지 않는 field가 자동적으로 xml로 bound 된다는 것이다. XmlTransient에 의해 어노테이션 되지 않는 한!!

2) GETTER/SETTER 요 한쌍은 xml로 bound되어지는데..!!
오직 JAXB 어노테이션의 일부분에 의해 명쾌하게 어노테이션이 될 때!!

getter setter 내용들이 나오는 것을 보아...VO에서 처리하는 것임을 알 수 있다!^^;

또한 PROPERTIES는 아래와 같다.

더보기

Every getter/setter pair in a JAXB-bound class
will be automatically bound to XML, unless annotated by XmlTransient.
Fields are bound to XML
only when they are explicitly annotated by some of the JAXB annotations.

위에서 많이 정리가 되었다면 이것은 껌이다.
따로 예외가 없다. 즉 범위가 모든~~~getter/setter 쌍이다.
Fields가 xml로 bound된다는 거다.(직렬화이므로 object -> xml)

이처럼 그 종류는 아래의 그림과 같다. 조건에 맞게 잘~~쓰면 될 것 같다^-^
나머지는 .(dot) 눌러서 살펴보시면 됩니다~^-^good!

Usage

@XmlAccessorType annotation can be used with the following program elements:

• package
• a top level class

See "Package Specification" in javax.xml.bind.package javadoc for additional common information.

This annotation provides control over the default serialization of properties and fields in a class.

The annotation @XmlAccessorType on a package applies to all classes in the package. The following inheritance semantics apply:

• If there is a @XmlAccessorType on a class, then it is used.
• Otherwise, if a @XmlAccessorType exists on one of its super classes, then it is inherited.
• Otherwise, the @XmlAccessorType on a package is inherited.

Defaulting Rules:

By default, if @XmlAccessorType on a package is absent, then the following package level annotation is assumed.

   @XmlAccessorType(XmlAccessType.PUBLIC_MEMBER)
 

By default, if @XmlAccessorType on a class is absent, and none of its super classes is annotated with @XmlAccessorType, then the following default on the class is assumed:

   @XmlAccessorType(XmlAccessType.PUBLIC_MEMBER)
 

This annotation can be used with the following annotations: XmlType, XmlRootElement, XmlAccessorOrder, XmlSchema, XmlSchemaType, XmlSchemaTypes, , XmlJavaTypeAdapter. It can also be used with the following annotations at the package level: XmlJavaTypeAdapter.

Since:

JAXB2.0

Version:

$Revision: 1.9 $

Author:

Sekhar Vajjhala, Sun Microsystems, Inc.

See Also:

XmlAccessType

또 다른 녀석~!!
@XMLRootElement

더보기

javax.xml.bind.annotation.XmlRootElement

@Target(value={TYPE})
@Retention(value=RUNTIME)

Maps a class or an enum type to an XML element.

Usage

The @XmlRootElement annotation can be used with the following program elements:

• a top level class
• an enum type

See "Package Specification" in javax.xml.bind.package javadoc for additional common information.

When a top level class or an enum type is annotated with the @XmlRootElement annotation, then its value is represented as XML element in an XML document.

This annotation can be used with the following annotations: XmlType, XmlEnum, XmlAccessorType, XmlAccessorOrder.

Example 1: Associate an element with XML Schema type

     // Example: Code fragment
     @XmlRootElement
     class Point {
        int x;
        int y;
        Point(int _x,int _y) {x=_x;y=_y;}
     }
 

     //Example: Code fragment corresponding to XML output
     marshal( new Point(3,5), System.out);
 

<SPAN style="FONT-SIZE: 11pt"><SPAN style="FONT-SIZE: 12pt"><SPAN style="FONT-SIZE: 11pt">     <!-- Example: XML output -->
     <FONT color=#c8056a><</FONT><FONT color=#ff8b16><FONT color=#c8056a>point</FONT></FONT><FONT color=#c8056a>></FONT>
       <FONT color=#f9b4cb><FONT color=#000000><</FONT>x<FONT color=#000000>></FONT></FONT> 3 </x>
       <<FONT color=#f9b4cb>y</FONT>> 5 </y>
    <FONT color=#c8056a> </point>
</FONT></SPAN></SPAN></SPAN> 

The annotation causes an global element declaration to be produced in the schema. The global element declaration is associated with the XML schema type to which the class is mapped.

<SPAN style="FONT-SIZE: 11pt"><SPAN style="FONT-SIZE: 10pt">     <!-- Example: XML schema definition -->
     <xs:<FONT color=#c8056a>element name="point"</FONT> type="point"/>
     <xs:<FONT color=#c8056a>complexType </FONT>name="point">
       <xs:<FONT color=#c8056a>sequence</FONT>>
         <xs:element name="x" type="xs:int"/>
         <xs:element name="y" type="xs:int"/>
       </xs:sequence>
     </xs:complexType>
</SPAN></SPAN> 

Example 2: Orthogonality(직교성(?)) to type inheritance(상속)

An element declaration annotated on a type is not inherited by its derived types. The following example shows this.

     // Example: Code fragment
     @XmlRootElement
     class Point3D extends Point {
         int z;
         Point3D(int _x,int _y,int _z) {super(_x,_y);z=_z;}
     }

     //Example: Code fragment corresponding to XML output * 
     marshal( new Point3D(3,5,0), System.out );

     <!-- Example: XML output -->
     <!-- The element name is point3D not point -->
     <point3D>
       <x>3</x>
       <y>5</y>
       <z>0</z>
     </point3D>

     <!-- Example: XML schema definition -->
     <xs:element name="point3D" type="point3D"/>
     <xs:complexType name="point3D">
       <xs:complexContent>
         <xs:extension base="point">
           <xs:sequence>
             <xs:element name="z" type="xs:int"/>
           </xs:sequence>
         </xs:extension>
       </xs:complexContent>
     </xs:complexType>
 

Example 3: Associate a global element with XML Schema type to which the class is mapped.

     //Example: Code fragment
     @XmlRootElement(name="PriceElement")
     public class USPrice {
         @XmlElement
         public java.math.BigDecimal price;
     }

     <!-- Example: XML schema definition -->
     <xs:element name="PriceElement" type="USPrice"/>
     <xs:complexType name="USPrice">
       <xs:sequence>
         <xs:element name="price" type="xs:decimal"/>
       </sequence>
     </xs:complexType>
 

Since:

JAXB2.0

Author:

Sekhar Vajjhala, Sun Microsystems, Inc.

정리 해보면
@XMLAccessorType는 bound to xml(JAXB기반 직렬화 object->xml)을 하는데 있어서 범위? 방식을 정하는 것이다. Field면 정적이지 않거나 임시적이지 않는 필드여야만 한다. 이러한 방식!

@XMLRootElement는 정보라고 보면 된다. object가 xml로 bound가 되어 질 때
아래와 같은 2가지 정보를 준다고 보면 된다.

• a top level class
• an enum type

정보를 주는 방식은 위에 보면 예제를 들어서 설명을 하고 있다.
특히 3번째 예제를 많이들 쓴다.
※ Example 3: Associate a global element with XML Schema type to which the class is mapped. 

추신..: 

xml 스키마 타입(클래스가 mapped된)을 가진 글로벌요소를 결부짓다???? 연합시키다??--;;

  Associate 는 뭐라고 해석해야하지..난감하다 ㅎㅎ느낌은 알꺼 같은데...;;

  -끝-

 

Java Decompiler Plugin For Eclipse IDE

1) 다운로드 제드

더보기

Official Jad website seem not working any more, try mirror download links instead.
 Jad Official website // 아래의 url로 접근해보았는데 접근이 되질 않는다..--;;
 http://www.kpdus.com/jad.html

 Jad mirror download // 1)으로 해보았더니 잘되었다.^-^good~
 1)  http://www.softpedia.com/get/Programming/Debuggers-Decompilers-Dissasemblers/JAD.shtml

2) http://www.varaneckas.com/jad

1)에서 jad.exe를 얻을 수가 있다. 이젠 이클립스 플러그인을 깔고 연동 시키면 된다.^-^good~

2) Download Jad Eclipse plugin
Download the Jad Eclipse plugin named “Jabclipse (net.sf.jadclipse_x.x.x.jar)”
 http://sourceforge.net/projects/jadclipse/ 

 3) Copy it to Eclipse plugin folder
Copy the downloaded Jad Eclipse plugin – Jabclipse(jadclipse_x.x.x.jar) to Eclipse plugin folder.
For example,
  D:\eclipse\plugins\net.sf.jadclipse_3.3.0.jar
 P.S No need to extract it, just copy the whole jar file.

아래의 그림처럼 플러그인 디렉토리에 다운받은 이클립스 플러그인을 넣어준다.

 

4) Restart Eclipse 재시작^-^

Restart Eclipse to make the plugin take effect.

5) Configure Jadclipse in Eclipse

In Eclipse, Click Window –> Preference –> Java –> Jadclipse , Key in Jad’s path in “Path to Decompiler” field
경로를 잡아줄 때는 풀path로 아래처럼 해주거나 jad 라고 써놓고 환경변수에다가 경로를 잡아주고 하는 방법이 있다.
보통 jdk path가 환경변수에 잡혀있기 때문에 bin아래에 넣어두고 Path to decompiler에는 jad라고 적혀있는 그대로 두면 된다.^-^good~~

6) Done
In Eclipse, try F3 into any class which does not has the source, Jad will decompile it automatically. 

7) 정말 중요한..jad 사용법!!!
     6번에서 처럼 F3을 이용한...decompile이 되어진다. 
      그것도 모르고..삽질을 올골차게 하였다..뉴뉴..
      왜냐면 테스트를 아래와 같이 하였을 때 오류가 났기 때문이다.
 

알아보니 위와 같이 하면 안된다고 한다...ㅜ_ㅜ ..
F3 or Ctrl+메소드 등으로 하면 된다..^-^b 

위에처럼 했을 때 결과는..

/*jadclipse*/// Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov.
 // Jad home page: http://www.kpdus.com/jad.html
 // Decompiler options: packimports(3) radix(10) lradix(10) 

위와 같은 주석이 달리면서 자바코드로 변환이 된다.^-^good~~~ 

다 받았으면 본격적인 셋팅을 해보자^-^
1) zip파일을 다 받았으면 압축을 풀자!
2) 압축을 풀고, bin/ 디렉토리까지의 경로를 환경변수 path에 등록하자!
D:\Spring\mysql-5.5.28-win32\mysql-5.5.28-win32\bin
참고그림

3) cmd 명령 프롬프트창을 열고 bin이 있는 곳까지 이동 한다.

4) 자! 이제 인스톨을 해보자~~~+ㅁ+ 
   설치 명령어는 mysqld --install  이다.
   제거 명령어는 mysqld --remove 가 되겠다.

5) 설치를 했다면 가동 시켜보자!
     가동 시키는 위치는 제어판 > 관리도구 > 서비스를 통해서 "start" 시킬 수 있다.
     (물론 명령어로도 수행 시킬 수 가 있다.)

6) 가동 시켰다면 제대로 연결이 되는지 테스트 해보자!!
    도스 프롬프트 창에서 mysql -uroot를 통해서 접속하여 보자!~^-^good

2012/10/28 - [DataBase] - MySQL 기본 문법(데이터베이스 보기, 사용하기)


참고사이트 : http://www.javamaster.org/lecture/mysql/mysql_install.html

Spring Batch ??
이것은 무엇인가?!

좋은 사이트 하나를 발견 하였다^-^good~
http://static.springsource.org/spring-batch/

public class DaoFactory{
    pubilc UserDao userDao(){
        /////////// 팩토리의 메소드는 UserDao 타입의 오브젝트를 어떻게 만들고, 

        // 어떻게 준비시킬지 결정 한다.
  ConnectionMaker connectionMaker = new DConnectionMaker();
   UserDao userDao = new UserDao(connectionMaker);

        /////////////////////////////////////////////////////////////
  return userDao;
   }
}

import org.springframework.context.annotation.Bean;


import org.springframework.context.annotation.Configuration;


...


@Configuration => 애플리케이션 컨텍스트 또는 빈 팩토리가 사용할 설정정보라는 표시


public class DaoFactory{


   @Bean         => 오브젝트 생성을 담당하는 IoC용 메소드라는 표시


   public UserDao(){


       return new UserDao(connectionMaker());


   }


   @Bean


   public   ConnectionMaker connectionMaker(){


       return new DConnectionMaker();


   }


}