Hyungu Im

<?xml version="1.0"?>

<project name="JBoss HelloWorld" default="ejbjar" basedir=".">

 <property environment="env"/>
 <property name="src.dir" value="${basedir}/src"/>
 <property name="jboss.home" value="D:\jboss\jboss-5.1.0.GA"/>
 <property name="build.dir" value="${basedir}/build"/>
 <property name="build.classes.dir" value="${build.dir}/classes"/>

 <path id="classpath">
  <fileset dir="${jboss.home}/lib">
   <include name="**/*.jar"/>
  </fileset>
  <fileset dir="${jboss.home}/common/lib">
  <include name="**/*.jar"/>
  </fileset>
 <fileset dir="${jboss.home}/server/default/lib">
   <include name="**/*.jar"/>
  </fileset>

<!--
  <fileset dir="${jboss.home}/server/default/deploy/ejb3.deployer">
   <include name="*.jar"/>
  </fileset>
  <fileset dir="${jboss.home}/server/default/deploy/jboss-aop-jdk50.deployer">
   <include name="*.jar"/>
  </fileset>
-->
  <pathelement location="${build.classes.dir}"/>
  <pathelement location="${basedir}"/>
 </path>

 <property name="build.classpath" refid="classpath"/>

 <target name="prepare">
  <delete dir="${build.dir}"/>
  <delete dir="${build.classes.dir}"/>
  <mkdir dir="${build.dir}"/>
  <mkdir dir="${build.classes.dir}"/>
 </target>

 <target name="compile" depends="prepare">
  <javac srcdir="${src.dir}"
         destdir="${build.classes.dir}"
         debug=on"
         deprecation=on"
         optimize="off"
         includes="**">
   <classpath refid="classpath"/>
  </javac>
 </target>

 <target name="ejbjar" depends="compile">
  <jar jarfile="build/helloworld.ejb3">
   <fileset dir="${build.classes.dir}">
    <include name="**/*.*"/>
   </fileset>
  </jar>
 </target>

 <target name="deploy" depends="ejbjar">
  <copy file="build/helloworld.ejb3" todir="${jboss.home}/server/default/deploy"/>
 </target>

 <target name="run" depends="ejbjar">
  <java classname="ejb.HelloClient" fork="yes" dir=".">
   <classpath refid="classpath"/>
  </java>
 </target>

 <target name="clean">
  <delete dir="${build.dir}"/>
  <delete file="${jboss.home}/server/default/deploy/helloworld.ejb3"/>
 </target>

</project>

이글은 #2를 수정한 글입니다.

먼저 CartController 입니다.

package com.onjmall.controller;

import static org.springframework.web.bind.annotation.RequestMethod.POST;

import java.util.HashMap;

import javax.inject.Inject;
import javax.inject.Provider;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import com.onj10.springcart.Item;
import com.onj10.springcart.ShoppingCart;
import com.onj10.springcart.ShoppingDao;


@Controller
@RequestMapping("/cart")
public class CartController {
   
    private Provider<ShoppingCart> shoppingCart;
    private ShoppingDao shoppingDao;
   
    @Inject
    public CartController(Provider<ShoppingCart> shoppingCart, ShoppingDao shoppingDao) {
        this.shoppingCart = shoppingCart;
        this.shoppingDao = shoppingDao;
    }
   
    @RequestMapping(value="/add", method=POST)
    public String addToCart(@RequestParam("selecteditems") String[] selecteditems, Model model) {
        try {
            for (int i=0; i<selecteditems.length; i++) {
               
                Item item = shoppingDao.getItem(Integer.parseInt(selecteditems[i]));
                shoppingCart.get().add(item, 1);  //TODO: 객체가 다르기 때문에 중복처리해서 갯수를 증가하도록 수정...
                System.out.println(item.getId() + "번 아이템이 담겼습니다");
            }
           
            //장바구니 보기
            HashMap<Item, Integer> map =
                    shoppingCart.get().getCartList();
           
            model.addAttribute("cart", map);
        } catch (Exception e) {
            e.printStackTrace();
        }
       
        return "cart/list";
    }
}

보는 것처럼 화면에서 체크박스를 선택한 항목을 장바구니에 넣는 부분입니다.

여기에서 위에 굵게 표시된 것처럼 Provider를 이용하지 않으면, session scope bean은

알기 어려운 에러가 납니다.

받아올때는 .get()으로 받아옵니다. 아직 Provider에 관해서 더 공부할 게 남았습니다.

그리고 RequestContextListener는 굳이 설정하지 않아도 되었습니다.

에러가 이것과 관련해서 나오는데 원인은 잘 모르겠습니다.

그리고 Todo항목은 카트에 넣을때마다 새로운 객체를 생성할 수 밖에 없고

그때마다 새로운 인스턴스가 새로운 키가 되는 구조라서(실제로 대부분의 쇼핑몰의 구조도 비슷하다고....)

ShoppingCartBean의 add메서드에서 키를 비교해서 다르면 넣는 코드(hashmap api를 보면, 금방 만들수 있는...)를 넣으면 되겠습니다.

이제 Spring MVC로 shoppingcart를 바꿔보겠다.

먼저 필요한 라이브러리

web-portlet

web-servlet

web-struts

web

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>JbossWeb</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
 
  <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/spring-cart.xml</param-value>
  </context-param>
 
  <listener>
      <listener-class>
          org.springframework.web.context.ContextLoaderListener
      </listener-class>
  </listener>
 
  <listener>
      <listener-class>
          org.springframework.web.context.request.RequestContextListener
      </listener-class>
  </listener>
 
  <servlet>
      <servlet-name>dispatcher</servlet-name>
      <servlet-class>
          org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
  </servlet>
 
  <servlet-mapping>
      <servlet-name>dispatcher</servlet-name>
      <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

위에서 RequestContextLoader가 바로 장바구니와 같이 scope를 세션레벨로 가지는 경우, 스프링빈에서 설정해야 하는데 이것을 스프링웹에서 Request로 받을수 있도록 해준다.

그리고 기존의 스프링빈도 받아야 하므로 ContextLoaderListener도 필요로 한다.

spring-cart.xml

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

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean id="shoppingCart"
        class="com.onj10.shoppingcart.ShoppingCartBean" init-method="doPostConstruct"
        destroy-method="doPreDestroy" scope="session">
    </bean>
   
   
</beans>

위 소스에서 가장 중요한 부분이 바로 scope="session"이라는 부분인데,

스프링빈은 일반적으로 싱클톤으로 즉 일단 한번 만들어지면 계속 생성되는 것이 아닌데,

쇼핑카트처럼 세션단위로 생성되어야 하므로 이렇게 스코프를 지정할 수 있다.

dispatcher-servlet.xml

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

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean id="cartController"
        class="com.onj10.controller.CartController">
        <property name="shoppingCart" ref="shoppingCart"/>
    </bean>
       
    <bean id="viewResolver"
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/view/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
   
   
</beans>

이부분은 일반적인 스프링엠브이시와 동일한다.

java에서는 먼저 컨트롤러가 있어야 하겠다.

CartController

package com.onj10.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import com.onj10.shoppingcart.CheckOutException;
import com.onj10.shoppingcart.Item;
import com.onj10.shoppingcart.ShoppingCart;


@Controller
public class CartController {
   
    private ShoppingCart shoppingCart;
   

    public void setShoppingCart(ShoppingCart shoppingCart) {
        this.shoppingCart = shoppingCart;
    }


    @RequestMapping("/cart.do")
    public ModelAndView cart() {
       
        Item item1 = new Item();
        item1.setId(1);
        item1.setName("샤넬가방1");
        item1.setPrice(1000);

        Item item2 = new Item();
        item2.setId(2);
        item2.setName("샤넬가방2");
        item2.setPrice(2000);

        shoppingCart.buy(item1, 1);
        shoppingCart.buy(item2, 2);



        try {
            shoppingCart.checkout();
        } catch (CheckOutException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
       
       
        ModelAndView mav = new ModelAndView();
        mav.setViewName("cart");
       
        return mav;
    }
   
   
}

Test.java와 거의 같지만 스프링 엠브이시 어노테이션 기반으로 작성했고 cart라는 뷰를 지정해서

모델앤드뷰를 리턴한다.

cart.jsp는 간단하게 다음과 같이 

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
   
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-ｅquiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
상품구입이 완료되었습니다.
</body>
</html>

기존의 쇼핑카트를 스프링 삼점일 버전으로 바꿔봤다.

이렇게 함으로 스프링과 스프링엠브이씨에 관해 좀더 알게 되었다.

먼저 ShoppingCart.java 인터페이스

package com.onj10.shoppingcart;

import java.util.HashMap;

public interface ShoppingCart {
    void buy(Item item, int quantity);
     
     HashMap<Item, Integer> getCartList();
     
     void checkout() throws CheckOutException;
}

보는 것처럼 @Remove와 같은 EJB에 종속적인 어노테이션이 사라졌다.!!

다음은 ShoppingCartBean 클래스이다.

package com.onj10.shoppingcart;

import java.util.HashMap;

public class ShoppingCartBean implements ShoppingCart {

    private HashMap<Item, Integer> cart;
   
    @Override
    public void buy(Item item, int quantity) {
        cart.put(item, quantity);
        System.out.println(item.getName() + ":" + quantity + " 구입");

    }

    @Override
    public HashMap<Item, Integer> getCartList() {
        return cart;
    }

    @Override
    public void checkout() throws CheckOutException {
        System.out.println("체크아웃");
        doPreDestroy();

    }
   
    // CallBackMethod
     public void doPostConstruct() {
      System.out.println("장바구니 생성");
      cart = new HashMap<Item, Integer>();
     }
     
     public void doPreDestroy() {
      System.out.println("장바구니 삭제");
      cart.clear();
      cart = null;
     }

}

여기에도 @PostConstruct, @PreDestory도 사라졌다.

그리고 @Remove로 자동 삭제되는 checkout를 명시적으로 doPreDestroy를 호출하면 된다.

물론 이것은 aop와 같은 것으로 부가관심사적 입장에서 생각할 수도 있겠지만,

아직은 aop가 말그대로 부가적인 관심사라서(나에게^^)

사양에서는 이것도 스프링자체적으로 지원한다고 했는데,

실제로 해보면 안된다.

 3.2 버전에서는 되려나~~

그리고, spring-cart.xml에서

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

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean id="shoppingCart"
        class="com.onj10.shoppingcart.ShoppingCartBean" init-method="doPostConstruct"
        destroy-method="doPreDestroy">
    </bean>
   
   
</beans>

와 같이 init-method, destroy-method로 대치되었음을 알수있다.

다음은 Test.java

package com.onj10.shoppingcart;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;



public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("com/onj10/shoppingcart/spring-cart.xml");
       
        ShoppingCart cart = (ShoppingCart) ctx.getBean("shoppingCart");
   
        Item item1 = new Item();
        item1.setId(1);
        item1.setName("샤넬가방1");
        item1.setPrice(1000);
       
        Item item2 = new Item();
        item2.setId(2);
        item2.setName("샤넬가방2");
        item2.setPrice(2000);
       
        cart.buy(item1, 1);
        cart.buy(item2, 2);
       
        try {
            cart.checkout();
        } catch (CheckOutException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
       
       
       
    }

}

c:\java\jboss-6.1.0.Final\server\default\conf\bindingservice.beans\META-INF\bindings-jboss-beans.xml에서 8080을 원하는 포트명으로 변경

...

<bean class="org.jboss.services.binding.ServiceBindingMetadata">
               <property name="serviceName">jboss.web:service=WebServer</property>
               <property name="bindingName">HttpConnector</property>
               <property name="port">7080</property>
               <property name="description">JBoss Web HTTP connector socket; also drives the values for the HTTPS and AJP sockets</property>
            </bean>

...

그냥 jsp에서

 try {

  InitialContext context = new InitialContext();   

  DataSource ds = null;   

  try{       

   ds = (DataSource)context.lookup("java:OracleDS");     

  }catch(Exception e){         

   e.printStackTrace();   

  } 

식으로 하면 잘 되는데 jstl이나 다른 곳에서 jndi를 참조할 경우 안될 경우가 있다.

이럴때는 

우선 web.xml에서

 <resource-ref>

  <res-ref-name>OracleDS</res-ref-name>

  <res-type>javax.sql.Datasource</res-type>

  <res-auth>Container</res-auth>

  </resource-ref>

를 추가하주고,

WEB-INF밑에 jboss-web.xml을 만든다.

내용은

<!DOCTYPE jboss-web PUBLIC

   "-//JBoss//DTD Web Application 5.0//EN"

   "http://www.jboss.org/j2ee/dtd/jboss-web_5_0.dtd">

<jboss-web>

  <resource-ref>

    <res-ref-name>OracleDS</res-ref-name>

    <jndi-name>java:/OracleDS</jndi-name>

  </resource-ref>

</jboss-web>

오랜만에 JBOSS 포스팅입니다.

3년이란 시간 참 빨리가네요...

시대도 EJB를 쓰던 시대에서 spring web으로 변했고, spring도 버전이 많이 올라가서 이전의 스프링 코딩이 안되는 경우가 많네요. 역시 개발을 배우려면 실전 프로젝트를 해봐야 한다는 것을 실감합니다.

그래서 다시 JBOSS 6.X버전에서 ejb를 빼고 web만 디플로이 되도록 만들어봤습니다.

<?xml version="1.0" encoding="UTF-8"?>
<project name="JBoss Web" default="compile" basedir=".">

 <property environment="env"/>
 <property name="src.dir" value="${basedir}/src"/>
 <property name="jboss.home" value="D:\jboss-6.1.0.Final"/>
 <property name="build.dir" value="${basedir}/build"/>
 <property name="build.classes.dir" value="classes"/>
 <!-- <property name="test.lib.dir" value="lib"/> -->

 <!-- Build classpath -->
 <path id="classpath">
  <fileset dir="${jboss.home}/lib">
   <include name="**/*.jar"/>
  </fileset>
  <fileset dir="${jboss.home}/server/test/lib">
   <include name="**/*.jar"/>
  </fileset>
  <pathelement location="${build.classes.dir}"/>

  <!-- JUnit TestCase Library -->
  <!--
  <fileset dir="${test.lib.dir}">
   <include name="*.jar"/>
  </fileset>
  <pathelement location="${basedir}"/> -->
 </path>
 
 <property name="build.classpath" refid="classpath"/>
 
 <target name="prepare">
  <delete dir="${build.dir}"/>
  <delete dir="${build.classes.dir}"/>
  <mkdir dir="${build.dir}"/>
  <mkdir dir="${build.classes.dir}"/>
 </target>

 <target name="compile" depends="prepare">
  <javac srcdir="${src.dir}"
         destdir="${build.classes.dir}"
         debug=on"
         deprecation=on"
         optimize="off"
         includes="**">
   <classpath refid="classpath"/>
  </javac>
  <delete dir="${build.classes.dir}/META-INF"/>
  <!--<copy file="config/persistence.xml" todir="${build.classes.dir}/META-INF"/>
  <copy file="config/log4j.properties" todir="${build.classes.dir}"/>-->
 </target>
<!-- 
 <target name="ejb.jar" depends="compile">
  <delete dir="dist"/>
  <mkdir dir="dist"/>
  <jar jarfile="dist/odjd.ejb3">
   <fileset dir="${build.classes.dir}">
    <include name="**/*.*"/>
   </fileset>
  </jar>
  <delete dir="build"/>
  <delete dir="${build.classes.dir}"/>
 </target>
-->
 <target name="emp.jar" depends="compile">
   <delete dir="dist"/>
 
   <!-- packaging .jar -->
   <jar jarfile="build/emp-web.jar">
    <fileset dir="${build.classes.dir}">
     <include name="**/*.*"/>
    </fileset>
   </jar>
   <delete dir="${build.classes.dir}"/>
 
   <!-- packaging .war -->
   <mkdir dir="${build.dir}/WebContent"/>
   <mkdir dir="${build.dir}/WebContent/WEB-INF"/>
   <copydir src="WebContent/WEB-INF" dest="${build.dir}/WebContent/WEB-INF"/>
   <!--  <copy file="config/jboss-web.xml" todir="${build.dir}/WebContent/WEB-INF"/>
   -->
   <copy todir="${build.dir}/WebContent">
    <fileset file="WebContent/*.*"/>
   </copy>
   <jar jarfile="build/emp-web.war">
    <fileset dir="${build.dir}/WebContent">
     <include name="**/*.*"/>
    </fileset>
   </jar>
   <delete dir="${build.dir}/WebContent"/>
 
   <!-- packaging .ear -->
   <mkdir dir="${build.dir}/META-INF"/>
   <jar jarfile="build/emp-web.ear">
    <fileset dir="${build.dir}">
     <include name="**/*.*"/>
    </fileset>
   </jar>
   <mkdir dir="dist"/>
   <copy file="${build.dir}/emp-web.ear" todir="dist"/>
   <delete dir="${build.dir}"/>
 </target>

 <target name="deploy.ear" depends="emp.jar">
  <copy file="dist/emp-web.ear" todir="${jboss.home}/server/test/deploy"/>
 </target>

 <target name="clean">
  <delete dir="${build.dir}"/>
  <delete dir="${build.classes.dir}"/>
  <delete dir="dist"/>
  <delete file="${jboss.home}/server/odjd/deploy/emp-web.jar"/>
  <delete file="${jboss.home}/server/odjd/deploy/emp-web.ear"/>
 </target>

</project>

훌륭한 오픈소스 EJB 컨테이너 JBOSS 설치법

다운로드 사이트:

http://www.jboss.org/jbossas/downloads/
 에서 jboss4.2.3.GA 을 다운받는다.

설치: 다운로드 받은 jboss를 압축을 풀어놓음

(예: d:\jboss)

동작확인:

%JBOSS%\bin폴더에서 run.bat 실행

웹마 등의 브라우저에서 http://localhost:8080

만약 8080포트가 쓰고 있다는 오류가 나면

%JBOSS%\server\default\deploy\jboss-web.deployer\server.xml이 있음

이곳에서 8080을 7080으로 바꾸고(7080세대는 역시 7080으로 해야하나??)

자기만의 서버 구축하기

%JBOSS%\server\안에 default를 복사해서 test란 폴더를 만든다.

그러면

run.bat -c test

하면 test에 있는 내용이 실행된다.

(기본은 run.bat 하면 default가 실행됨)

서버중지

1. 그냥 창을 닫는다.  ( 나중에 메모리 부족현상 발생가능성)

2. %JBOSS%\bin폴더에서 Shutdown -S  정상적으로 종료된다.

(Shutdown하면 원격으로 실행되어 있는 JBOSS도 닫을수 있다고 함. 아직 해보진 못했음.

서브PC하나 사서 해보려고. 아니면 학원에서 해볼수도 있지만.)

* ShopTest.java

package ejb;

import java.util.List;

import javax.ejb.Local;

@Local
public interface ShopTest {
 
 public void insert(Shop shop);
 
 public List<Menu> getMenu(Shop shop);
}

* ShopTestBean.java

package ejb;

import java.util.List;

import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Stateless
public class ShopTestBean implements ShopTest {

 @PersistenceContext(unitName="manager")
 EntityManager em;
 
 public void insert(Shop shop) {
  em.persist(shop);
 }

 public List<Menu> getMenu(Shop shop) {
  Shop shop1 = em.find(Shop.class, shop.getId());
  List<Menu> menuList = (List<Menu>)shop1.getMenu();
  
  return menuList;
 }

}

* helloentity3-1.jsp

<%@ page language="java" contentType="text/html; charset=EUC-KR"
    pageEncoding="EUC-KR"%>
<%@ page import="javax.naming.InitialContext" %>
<%@page import="ejb.ShopTest, ejb.Shop, ejb.Address, ejb.Menu, java.util.*"%>
<%!
private ShopTest test = null;
public void jspInit() {
 try {
  InitialContext ctx = new InitialContext();
  test = (ShopTest) ctx.lookup("ajax/ShopTestBean/local");
 } catch(Exception e) {
  e.printStackTrace();
 }
}

%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>
<meta http-ｅquiv="Content-Type" content="text/html; charset=EUC-KR">
<title>Insert title here</title>
</head>
<body>
<h1>Shop 200 Menu List</h1>

<%
 Shop shop = new Shop();
 shop.setId(200);
 List<Menu> list = test.getMenu(shop);
 
%>

<table>
<tr>
<td>이름</td><td>설명</td><td>가격</td>
</tr>
<%
 for (Iterator iter = list.iterator(); iter.hasNext();) {
  Menu menu = (Menu)iter.next();
%>
<tr>
<td><%=menu.getName() %></td><td><%=menu.getDescription() %></td><td><%=menu.getPrice() %></td>
</tr>
<%
 }
%>

</table>

</body>
</html>

package ejb;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
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.SequenceGenerator;
import javax.persistence.Table;

@Entity
@Table(name = "EJB_SHOP")
@SequenceGenerator(name = "ShopSequence", sequenceName = "SHOP_SEQ", initialValue = 1)
public class Shop implements Serializable {

 private int id;
 private String shopName;
 private String branch;
 private String telephone;
 private String etc;
 private String address;

 
 private Address addr;

 private Collection<Menu> menu = new ArrayList(); // Menu:Shop = n:1

 public Shop() {
 }

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "ShopSequence")
 public int getId() {
  return id;
 }

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

 public String getShopName() {
  return shopName;
 }

 public void setShopName(String shopName) {
  this.shopName = shopName;
 }

 public String getBranch() {
  return branch;
 }

 public void setBranch(String branch) {
  this.branch = branch;
 }

 public String getTelephone() {
  return telephone;
 }

 public void setTelephone(String telephone) {
  this.telephone = telephone;
 }

 public String getEtc() {
  return etc;
 }

 public void setEtc(String etc) {
  this.etc = etc;
 }

 public String getAddress() {
  return address;
 }

 public void setAddress(String address) {
  this.address = address;
 }

 
 @OneToOne(cascade = CascadeType.PERSIST, fetch = FetchType.EAGER)
 @JoinColumn(name = "ADDR_ID")
 public Address getAddr() {
  return addr;
 }

 public void setAddr(Address addr) {
  this.addr = addr;
 }
 
 

 
 @OneToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
 @JoinTable(name = "EJB_SHOP_MENU", joinColumns = {@JoinColumn(name="SHOP_ID")}, inverseJoinColumns = {@JoinColumn(name="MENU_ID")})
 public Collection<Menu> getMenu() {
  return menu;
 }

 public void setMenu(Collection<Menu> menu) {
  this.menu = menu;
 }

 public String toString() {
  return "점포{" +
   "id=" + id +
   ", 점포명='" + shopName + "'" +
   ", 지점명='" + branch + "'" +
   ", 전화번호='" + telephone + "'" +
   ", 주소='" + address + "'" +
   ", 기타='" + etc + "'" +
   "}";
 }
}