XML 3일차 - Map

2020.09.18(금)

 

ChefVO.java

package com.sist.dao;
/*
 *   1. MyBatis => 반드시 (변수=컬럼명) => 불일치시에는 값을 받지 못한다 
 *      => 받는 방법 => XML코드에서 매칭 
 *         <result property="image" column="poster">
 */
public class ChefVO {
    private String poster;
    private String chef;
    private String mem_cont1;
    private String mem_cont3;
    private String mem_cont7;
    private String mem_cont2;
	public String getPoster() {
		return poster;
	}
	public void setPoster(String poster) {
		this.poster = poster;
	}
	public String getChef() {
		return chef;
	}
	public void setChef(String chef) {
		this.chef = chef;
	}
	public String getMem_cont1() {
		return mem_cont1;
	}
	public void setMem_cont1(String mem_cont1) {
		this.mem_cont1 = mem_cont1;
	}
	public String getMem_cont3() {
		return mem_cont3;
	}
	public void setMem_cont3(String mem_cont3) {
		this.mem_cont3 = mem_cont3;
	}
	public String getMem_cont7() {
		return mem_cont7;
	}
	public void setMem_cont7(String mem_cont7) {
		this.mem_cont7 = mem_cont7;
	}
	public String getMem_cont2() {
		return mem_cont2;
	}
	public void setMem_cont2(String mem_cont2) {
		this.mem_cont2 = mem_cont2;
	}
  
  
}

 

RecipeVO.java

package com.sist.dao;
// 자바 => 데이터 보호 (캡슐화 : 변수는 은닉화 메소드를 이용해서 접근하는 방식)
// 은닉화 => private
/*
 *   마이바티스 , 스프링 
 *   변수 : public ===> 값을 설정 , 값을 얻어오는 경우 ==> setXxx(),getXxx()
 *   보안프로그램 기본 
 *   
 *   => 재사용기법 
 *      = 포함 클래스
 *      = 상속 (속도문제)
 *      = 재사용 => 프로그래머들이 만들 클래스,변수 ==> 저장하는 공간 (XML)
 *      = 저장하지 않고 프로그래머가 직접 처리 => 어노테이션 
 */
public class RecipeVO {
    private int no;
    private String title;
    private String poster;
    private String chef;
    private String link;
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getPoster() {
		return poster;
	}
	public void setPoster(String poster) {
		this.poster = poster;
	}
	public String getChef() {
		return chef;
	}
	public void setChef(String chef) {
		this.chef = chef;
	}
	public String getLink() {
		return link;
	}
	public void setLink(String link) {
		this.link = link;
	}
  
}

 

RecipeDAO.java

package com.sist.dao;
import java.io.*;
import java.util.*;
/*
 *    순서 (코딩)
 *    1) SQL 문장   ============================> recipe-mapper.xml
 *    2) SQL 문장을 읽어와서 실행 => 결과값을 얻어 온다 ==> RecipeDAO (메소드 만든다)
 *    3) 데이터를 받아서 출력  ===> 메소드 호출 후에 출력  ==> recipe.jsp
 */
/*
 *   Collection 클래스  ==> 자료 구조 (데이터 저장하는 방법)
 *   ========== 데이터를 저장하고 쉽게 저장이 가능하게 만든 클래스의 집합 
 *     List ==============> 오라클
 *      = 순서를 가지고 있다 
 *      = 데이터가 중복이 가능하다 
 *      = ***ArrayList,Vector,LinkedList
 *     Set  =============> 사용빈도가 거의 없다 
 *      = 순서가 없다 
 *      = 데이터가 중복이 없다 
 *      = HashSet , TreeSet  
 *     Map
 *      = 두개를 동시에 저장이 가능 (키(id),값) => request,response
 *        ?no=10  ==> request.push("no",10)
 *      = ***HashMap(hashtable의 단점을 보완),hashtable
 *      = JSON(MongoDB)
 *      = (id,"admin")
 *      = 클래스 등록 , sql등록 
 *      =================================== 저장 방법 
 */
/*
 *   1. XML을 읽어와서 => 데이터 저장 
 *                    ========= 셋팅 (getConnection(),disConnection())
 *       SqlSessionFactory(Mybatis에서 지원하는 클래스)
 *       =================
 *       XML 파싱 
 *   2. id를 설정해주고 sql을 실행이 가능하게 만든다 
 */

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
public class RecipeDAO {
   private static SqlSessionFactory ssf;
   // 자동 처리 => 변수에 초기화
   static 
   {
	   try
	   {
		   // 1. XML 파일 읽기 
		   Reader reader=Resources.getResourceAsReader("Config.xml");
		   // 파일명이 대소문자 구분 
		   // 파싱 (XML에 등록된 데이터 읽기) build(xml 파일설정)
		   // 파싱한 결과를 ssf에 첨부 => getConnection(),disConnection()
		   ssf=new SqlSessionFactoryBuilder().build(reader); // SAX를 이용해서 등록된 데이터 
		   // Map에 저장을 놓고 사용자가 요청시마다 처리 => id => SQL문장을 실행한 결과를 넘겨준다 
	   }catch(Exception ex)
	   {
		   ex.printStackTrace();// 예외처리를 하지 않으면 에러 처리가 어렵다 (XML안에서 에러)
	   }
   }
   // 활용 
   /*
    *   start , end => Map
    */
   public static List<RecipeVO> recipeListData(Map map)
   {
	   List<RecipeVO> list=new ArrayList<RecipeVO>();
	   SqlSession session=null;
	   // Connection
	   // 에러 처리 => 예외처리
	   try
	   {
		   session=ssf.openSession();// Connection이 미리 만들어져 있다 (만들어진 Connection객체 주소를 가지고 온다)
		   list=session.selectList("recipeListData",map); // SQL문장을 받아 온다 => 실행 =결과값 
		   // list 모든 결과값을 담아준다 
		   //                       id , #{}에 값을 채운다
		   /*
		    *   selectList(String id)
		    *   selectList(String id,Object obj)
		    *   Object => 모든 데이터형을 받을 수 있는 클래스 
		    *   int,String ,Map ,~VO
		    *   받을 수 있는 데이터가 1개 ==> 여러개를 전송 => Map으로 묶어서 전송,~VO로 묶어서 전송 
		    */
	   }catch(Exception ex)
	   {
		   // 에러 처리
		   System.out.println(ex.getMessage());
	   }
	   finally
	   {
		   if(session!=null)
			   session.close();
	   }
	   return list;
   }
   // 총페이지를 구하는 메소드 : recipe-mapper.xml(SQL문장 저장) , RecipeDAO(사용요청시마다 처리)
   public static int recipeTotalPage()
   {
	   int total=0;
	   SqlSession session=null;
	   try
	   {
		   // 미리 생성해 둔 Connection 객체를 얻어 온다 
		   session=ssf.openSession();
		   total=session.selectOne("recipeTotalPage");
		   // SELECT CEIL(COUNT(*)/12.0) FROM recipe
		   // 데이터가 한개(row,record) => selectOne()
		   /*
		    *    id     name    sex
		    *    ==================
		    *    aaa    hong    man   ====> selectOne()  한줄 (상세보기)
		    *    
		    *    id     name    sex
		    *    ==================
		    *    aaa    hong    man   ====> selectList() 여러줄 (목록) 
		    *    aaa    hong    man
		    *    aaa    hong    man
		    */
	   }catch(Exception ex)
	   {
		   // 에러만 처리 
		   ex.printStackTrace();
	   }
	   finally
	   {
		   if(session!=null)// 오라클을 연결하고 있다면 
			   session.close(); // 닫기 ============> DBCP(재사용이 가능하게 반환)
		   // DataBase Connection Pool 
		   //                     ===== Connection을 관리는 영역
	   }
	   return total;
   }
   
   // chef 목록 얻어 오기 
   public static List<ChefVO> chefListData(Map map)
   {
	   // map => 시작위치값 , 끝위치값  ==> 20개 => table제작 
	   List<ChefVO> list=new ArrayList<ChefVO>();
	   // 오라클 연결 => SQL문장을 실행한 후에 결과값을 받아 온다 
	   SqlSession session=null;
	   try
	   {
		   // 연결할 수 있는 객체 얻기 
		   session=ssf.openSession();
		   // SQL문장을 보내고 결과값을 받는다 
		   list=session.selectList("chefListData",map);
		   // 열기 , 닫기 => 자동화 (Annotation)
		   // 데이터 얻기를 완료 ==> jsp에 출력 
	   }catch(Exception ex)
	   {
		   ex.printStackTrace();
	   }
	   finally
	   {
		   // 닫기 ==> 반환 (재사용이 가능)
		   if(session!=null)
			   session.close();
	   }
	   return list;
   }
   // chef의 총페이지 받기 
   public static int chefTotalPage()
   {
	   int total=0;
	   // 연결 객체 => SqlSession(오라클 연결)
	   SqlSession session=null;
	   try
	   {
		   //연결 
		   session=ssf.openSession();
		   // 결과값을 달라 
		   total=session.selectOne("chefTotalPage");//매개변수 => id (대소문자 구분)
	   }catch(Exception ex)
	   {
		   ex.printStackTrace();
	   }
	   finally
	   {
		   if(session!=null)// 연결중이면 
			   session.close();
	   }
	   return total;
   }
   // chef의 작품을 20개만 가지고 온다 
   public static List<RecipeVO> chefMakeRecipe(String chef)
   {
	   // 예외처리는 필수가 아니다 (컴파일 예외가 아니다)
	   List<RecipeVO> list=new ArrayList<RecipeVO>();
	   // List(interface) => ArrayList의 상위 클래스 
	   // 연결 
	   SqlSession session=null;
	   try
	   {
		   // 연결 시작 
		   session=ssf.openSession();
		   // 데이터 값을 받는다 
		   list=session.selectList("chefMakeRecipeData",chef);
		   // id명을 전송하고 SQL문장을 받아서 실행 => 결과값을 넘겨준다 
		   // VO=>selectOne(),List=>selectList()
	   }catch(Exception ex)
	   {
		   // 에러 처리 
		   ex.printStackTrace();
	   }
	   finally
	   {
		   if(session!=null)//연결되었다면 
			   session.close();// 반환(재사용이 가능하게 만든다)
	   }
	   return list;
   }
}

 

recipe-mapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- PreparedStatement,ResultSet 
     1. 일반 JDBC (***)
     2. JOIN 
     3. PL/SQL
     4. 동적 SQL
-->
<!DOCTYPE mapper
 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- SQL문장을 저장하는 위치
     namespace : XML에서 package
 -->
<mapper namespace="com.sist.dao.recipe-mapper">
<!-- 
     (cache-ref | cache | resultMap* | parameterMap* | sql* | insert* | update* | delete* | select*)+
     * : 0번이상 사용이 가능  
     | : 선택 (필요한 부분만 사용이 가능)
     
     resultMap : 컬럼명과 VO에 등록된 변수명 틀릴경우에 매칭한다 
                 class AVO
                 {
                     private int no;
                 }
                 Database A테이블에 => mno
                 ==> JOIN사용시 반드시 사용 
                 SELECT empno,ename,job,emp.deptno,loc,dname
                                        =========== emp.deptno = deptno
                 FROM emp,dept
                 WHERE emp.deptno=dept.deptno;
     parameterMap : PL/SQL (PROCEDURE) 
                    CREATE PROCEDURE por_name(no NUMBER....)
     sql : 반복적으로 수행되는 부분을 모아서 재사용 
     insert : 데이터를 추가 
     update : 데이터를 수정 
     delete : 데이터를 삭제 
     select : 데이터를 검색 
     ***** MyBatis의 단점은 태그한개에 여러개의 SQL문장을 사용할 수 없다 
           태그 한개당 1개의 SQL문장을 작성한다 
      <select>
        SELECT * FROM emp
        SELECT * FROM dept ==> 오류 ==> SQL문장뒤에 ';'을 사용하면 오류
      </select>
      String sql="SELECT * FROM emp"
      
           데이터값을 설정
      SELECT * FROM emp WHERE empno=? 
      => ?를 사용하지 않는다   #{empno},${empno}
                        ======== ===========> 컬럼명 , 테이블명을 사용 
                                            일반 데이터 값  => getEmpno()
     ***** XML코드는 HTML가 다르게 대소문자를 구분 
     
         모든  태그는 필수적으로 사용해야 돼는 속성 : id (중복이 없어야 한다)
         ==> id를 가지고 SQL문장을 찾는다 
         <select id="aaa">
           SELECT * FROM emp
         </select>
         <select id="aaa">
           SELECT * FROM dept
         </select>
                 키      값  ======> Map : 키,값  (값은 중복이 가능,키는 중복을 할 수 없다)
         =======================
         aaa   SELECT * FROM emp
         aaa   SELECT * FROM dept
         =======================
 -->
   <!--  데이터를 가지고 오는 SQL (recipe)  -->
   <!-- 
        id  ========> 식별자 (sql문장을 찾아서 수행요청할때 사용되는 데이터)
        resultType ===> SQL문장을 실행시에 결과값을 받는 클래스 등록 
        
        <select id="aaa" resultType="RecipeVO">
          SELECT * FROM recipe => 실행한 결과 => RecipeVO => ArrayList
                                             =========를 받아서 ArrayList에 첨부
                                             selectList => VO를 받아서 add()
                                             selectOne  => VO 1개만 받는다 
        </select>
        <select id="aaa" resultType="int">
          SELECT COUNT(*) FROM recipe => 실행한 결과 => int
        </select>
        <select id="aaa" resultType="String">
          SELECT pwd FROM recipe => 실행한 결과 => String
        </select>
        
        paramterType : ?에 값을 첨부
        <select id="aaa" resultType="EmpVO" parameterType="int">
         SELECT * FROM emp
         WHERE empno=#{empno}
        </select>
        
        <select id="aaa" resultType="EmpVO" parameterType="EmpVO">
         SELECT * FROM emp
         WHERE empno=#{empno} AND ename=#{ename}
                     ========           =========
                     #{empno} => vo.getEmpno()  vo.getEname()
        </select>
        
              만약에 VO에 없는 데이터값(여러개 있는 경우)이 들어 갈때  ==> java.util.Map
        WHERE num BETWEEN #{start} AND #{end}
        
               요청에 들어가는 데이터가 여러개 있는 경우 : ~VO , Map
               
               resultType=""  값을 받을 경우
               parameterType="" ?에 값을 채워주는 변수를 설정(일반변수,~VO,Map)
    -->
   <select id="recipeListData" resultType="RecipeVO" parameterType="java.util.Map">
      SELECT no,title,poster,chef,num 
      FROM (SELECT no,title,poster,chef,rownum as num 
      FROM (SELECT no,title,poster,chef 
      FROM recipe ORDER BY no DESC))
      WHERE num BETWEEN #{start} AND #{end}
      <!-- 
            Map map=new HashMap()
            map.put("start",1)
            map.put("end",10)
            <select id="recipeListData" resultType="RecipeVO" parameterType="java.util.Map">
            DAO에서 메소드 제작 
            public RecipeVO recipeListData(Map map)
                   ========               =========
                   resultType             parameterType
            public ArrayList<RecipeVO> recipeListData(Map map)
                   ========               =========
                   resultType             parameterType
                   
            ? 사용하지 않고  #{} , ${}
       -->
   </select>
   <!-- 
       1. 사용법 
          1) XML을 이용해서 필요한 데이터 전송 
          2) Annotation을 이용해서 필요한 데이터 전송 
             ==========
       2. 속도,쉽게 코딩(마이바티스,스프링:표준화)=분석이 쉽다
                     ===================
                                                 라이브러리 
    -->
    <!-- 총페이지 구하기  -->
    <select id="recipeTotalPage" resultType="int">
      <!-- 
         resultType="int"
         parameterType="" 
         =필요시만 사용 
         
                 오라클 내장 함수
            = 단일행 함수
                            문자함수
                  LENGTH 
                  SUBSTR
                  INSTR
                  RPAD
                            숫자함수
                  ROUND , TRUNC , CEIL
                            날짜함수
                  SYSDATE , MONTHS_BETWEEN
                            변환함수
                  TO_CHAR
                            기타함수
                  NVL (CASE , DECODE)
            = 집합 함수
               COUNT , MAX  , RANK
               
       -->
       SELECT CEIL(COUNT(*)/12.0) FROM recipe
    </select>
</mapper> 

 

chef-mapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <!-- chef-mapper.xml
    1. package 설정 => namespace(경로명을 지정)
  -->
<mapper namespace="com.sist.dao.chef-mapper">
  <!-- SQL 문장을 저장 
       <select> => SELECT문장 사용
       <insert> => SELECT,INSERT
       <update> => UPDATE
       <delete> => DELETE 
       =========================== 태그안에 SQL문장은 한개만 사용이 가능 
                                   예외) insert만 두개의 문장을 사용할 때도 있다 (자동 증가번호 만들때=> INSERT)
   -->
   <select id="chefListData" resultType="ChefVO" parameterType="java.util.Map">
     <!-- SQL문장이 들어가는 위치 -->
     SELECT poster,chef,mem_cont1,mem_cont3,mem_cont7,mem_cont2,num
     FROM (SELECT poster,chef,mem_cont1,mem_cont3,mem_cont7,mem_cont2,rownum as num 
     FROM (SELECT poster,chef,mem_cont1,mem_cont3,mem_cont7,mem_cont2
     FROM chef))
     WHERE num BETWEEN #{start} AND #{end}
     <!-- 
        SELECT poster,chef,mem_cont1,mem_cont3,mem_cont7,mem_cont2,num
        FROM (SELECT poster,chef,mem_cont1,mem_cont3,mem_cont7,mem_cont2,rownum as num 
        FROM (SELECT poster,chef,mem_cont1,mem_cont3,mem_cont7,mem_cont2
        FROM chef))
        WHERE num BETWEEN ? AND ?
        
        ps.setInt(1,map.get("start"))
        ps.setInt(2,map.get("end"))
      -->
      <!-- 
                 마이바티스에서 실행할 수 있게 ==> 라이브러리 호출 ==> DAO(제어) => 자바에서 호출 
       -->
   </select>
   <!-- 총페이지 구하기 -->
   <select id="chefTotalPage" resultType="int">
     SELECT CEIL(COUNT(*)/20.0) FROM chef
     <!-- 올림 함수 CEIL() : 결과값은 DAO-->
   </select>
   <!-- chef의 작품을 얻어 온다  -->
   <select id="chefMakeRecipeData" resultType="RecipeVO" parameterType="String">
     SELECT  title, poster , chef , rownum FROM recipe
     WHERE chef=#{chef} AND rownum&lt;=20
     <!-- 
          < => lt; 
          > => gt;
      -->
   </select>
</mapper>

 

Config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--  Connection : getConnection(),disConnection()
      1개만 생성 
      => src 폴더에 생성
 -->
 <!DOCTYPE configuration
   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
   "http://mybatis.org/dtd/mybatis-3-config.dtd">
 <!-- 
     (properties?, ===> properties 파일을 만들어서 중요한 정보들을 저장 
                        드라이버 이름 , URL, Username, Password(보안)
      settings?,   ===> 이미 실행된 SQL문장을 저장 재사용 
      typeAliases?, ==> VO을 저장(마이바티스 자체에서 값을 받아서 VO에 첨부)
      typeHandlers?, => 오라클 데이터형 = 자바 데이터형을 매칭 
      environments?, => 오라클 연결을 위한 정보를 셋팅 
      mappers?)  => SQL문장을 저장한 파일 등록 
      
      XML => 태그를 사용하는 순서가 존재
  -->
 <configuration>
   <typeAliases>
     <!-- VO를 등록하는 위치 => 마이바티스 클래스를 메모리 할당하고 set메소드를 데이터를 저장-->
     <!-- type에는 클래스명 등록  -->
     <typeAlias type="com.sist.dao.RecipeVO" alias="RecipeVO"/>
     <typeAlias type="com.sist.dao.ChefVO" alias="ChefVO"/>
     <!-- 
          while(rs.next())
          {
              RecipeVO vo=new RecipeVO();
              vo.setNo(rs.getInt("no"))
          }
      -->
   </typeAliases>
   <!-- 오라클 연결 = 정보를 저장 -->
   <environments default="development">
     <!-- (environment)+ => (+) 반드시 한번이상을 코딩을 한다 
          ? => 한번 사용한다 , 사용하지 않을 수 있다 
     -->
     <environment id="development">
       <!-- 
            (transactionManager,dataSource) => 기호가 존재하지 않을 경우 : default
            default => 반드시 한번만 사용 사용이 가능 
        -->
        <transactionManager type="JDBC"/>
        <!-- 
                         일괄 처리 : COMMIT,ROLLBACK
              COMMIT : 정상수행 => 저장 (INSERT,UPDATE,DELETE)
              ROLLBACK : 비정상 수행을 했을 경우 => 이전 명령을 취소
              JDBC => AutoCommit (자동으로 commit을 수행)
              JDBC , MANAGED (프로그래머 직접 처리) : 사용하지 않는다 
         -->
        <dataSource type="POOLED">
          <!-- dataSource : 데이터베이스의 정보를 저장하는 클래스 => Manager에게 전송 
               UNPOOLED : 요청시마다 오라클 연결 ,종료를 반복(속도가 늦다)
                          DAO(getConnection(),disConnection()) => 전에 만든 DAO
               POOLED : 일반적으로 가장 많이 사용하는 방식
                        Connection을 미리 연결해 놓고 요청시마다 연결된 주소를 넘겨주고 
                                            사용이 종료되면 재사용을 하는 프로그램  => DBCP
                         1) Connection의 객체가 제한을 할 수 있고 
                         2) 속도가 빠르다
                         3) 여러명이 동시접속시에 종료하지 않는다 
               JNDI : POOLED => 셋팅부분이 많이 존재 (고정된 데이터베이스 연결시 사용)
           -->
           <!-- 미리 Connection을 만들기 위해서는 오라클 정보를 넘겨준다 
                             디폴트 : 8개  
            -->
            <property name="driver" value="oracle.jdbc.driver.OracleDriver"/>
            <property name="url" value="jdbc:oracle:thin:@211.238.142.000:1521:XE"/>
            <property name="username" value="hr"/>
            <property name="password" value="happy"/>
            <!-- Connection을 많이 설정 : 프로젝트를 시작 -->
        </dataSource>
     </environment>
   </environments>
   <!-- SQL문장의 위치를 등록  -->
   <mappers>
      <!-- 
               자체 폴더에 존재 : resource => 경로명 
               원격 : url
               마이바티스 ,스프링 => 경로명 (자동 인식 : src)
       -->
      <mapper resource="com/sist/dao/recipe-mapper.xml"/>
      <mapper resource="com/sist/dao/chef-mapper.xml"/>
   </mappers>
 </configuration>

 

recipe.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" import="java.util.*,com.sist.dao.*"%>
<%
    // 1. 사용자의 요청 내용을 받는다 (페이지)
    String strPage=request.getParameter("page");
    if(strPage==null)
    	strPage="1";
    // 2. 요청을 받아서 ==> 데이터베이스에 있는 데이터를 받아 온다
    int curpage=Integer.parseInt(strPage);
    // Map을 요청 
    int rowSize=12;
    int start=(rowSize*curpage)-(rowSize-1); // rownum (시작이 1부터 시작)
    int end=rowSize*curpage;
    // Nap에 묶어서 전송
    Map map=new HashMap();
    map.put("start",start);
    map.put("end",end);
    
    List<RecipeVO> list=RecipeDAO.recipeListData(map);
    // static => 메모리할당 할 필요가 없다 => 자동으로 저장이 된다 
    int totalpage=RecipeDAO.recipeTotalPage();// 총페이지를 DB로 부터 받아 온다 
    // 3. 받아 온 데이터 출력 
    
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap.min.css">
<!-- CSS -->
<style type="text/css">
h1 {
     text-align: center
}
.pages {
  /*가운데 정렬*/
  margin: 0px auto;
  text-align: center;
}
</style>
</head>
<body>
   <div class="container">
     <h1>10000개의 레시피</h1>
     <div class="row">
       <!-- 출력 위치 -->
       <%
           for(RecipeVO vo:list)
           {
       %>
                <div class="col-md-3">
			      <div class="thumbnail">
			        <a href="#" target="_blank">
			          <img src="<%=vo.getPoster() %>" alt="Lights" style="width:100%">
			          <div class="caption">
			            <p><%=vo.getTitle() %></p>
			            <p><%=vo.getChef() %></p>
			          </div>
			        </a>
			      </div>
			    </div>
       <%
           }
       %>
     </div>
     <div class="row pages">
        <a href="recipe.jsp?page=<%= curpage>1?curpage-1:curpage %>" class="btn btn-sm btn-danger">이전</a>
          <%=curpage %> page / <%=totalpage %> pages
        <a href="recipe.jsp?page=<%= curpage<totalpage?curpage+1:curpage %>" class="btn btn-sm btn-primary">다음</a>
     </div>
   </div>
</body>
</html>

 

chef.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" import="java.util.*,com.sist.dao.*"%>
<%
    // 1. 사용자의 요청 내용을 받는다 (페이지)
    String strPage=request.getParameter("page");
    if(strPage==null)
    	strPage="1";
    // 2. 요청을 받아서 ==> 데이터베이스에 있는 데이터를 받아 온다
    int curpage=Integer.parseInt(strPage);
    // Map을 요청 
    int rowSize=12;
    int start=(rowSize*curpage)-(rowSize-1); // rownum (시작이 1부터 시작)
    int end=rowSize*curpage;
    // Nap에 묶어서 전송
    Map map=new HashMap();
    map.put("start",start);
    map.put("end",end);
    
    List<RecipeVO> list=RecipeDAO.recipeListData(map);
    // static => 메모리할당 할 필요가 없다 => 자동으로 저장이 된다 
    int totalpage=RecipeDAO.recipeTotalPage();// 총페이지를 DB로 부터 받아 온다 
    // 3. 받아 온 데이터 출력 
    
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap.min.css">
<!-- CSS -->
<style type="text/css">
h1 {
     text-align: center
}
.pages {
  /*가운데 정렬*/
  margin: 0px auto;
  text-align: center;
}
</style>
</head>
<body>
   <div class="container">
     <h1>10000개의 레시피</h1>
     <div class="row">
       <!-- 출력 위치 -->
       <%
           for(RecipeVO vo:list)
           {
       %>
                <div class="col-md-3">
			      <div class="thumbnail">
			        <a href="#" target="_blank">
			          <img src="<%=vo.getPoster() %>" alt="Lights" style="width:100%">
			          <div class="caption">
			            <p><%=vo.getTitle() %></p>
			            <p><%=vo.getChef() %></p>
			          </div>
			        </a>
			      </div>
			    </div>
       <%
           }
       %>
     </div>
     <div class="row pages">
        <a href="recipe.jsp?page=<%= curpage>1?curpage-1:curpage %>" class="btn btn-sm btn-danger">이전</a>
          <%=curpage %> page / <%=totalpage %> pages
        <a href="recipe.jsp?page=<%= curpage<totalpage?curpage+1:curpage %>" class="btn btn-sm btn-primary">다음</a>
     </div>
   </div>
</body>
</html>

 

chef_list.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" import="java.util.*,com.sist.dao.*"%>
<%
   // 사용자가 보내준 데이터 받기  ==> chef명 받기
   //  ?chef=값 ==> 사용자가 보낸 모든 데이터는 request안에 저장
   String chef=request.getParameter("chef");
   // SQL문장을 작성 => chef-mapper.xml
   // 쉐프가 만든 레시피를 DAO를 통해서 데이터를 얻어 온다 
   // DAO에서 데이터베이스(오라클) 연결 => 실행 결과를 얻어 온다 
   List<RecipeVO> list=RecipeDAO.chefMakeRecipe(chef);
   // DAO 들어온 데이터를 화면에 출력 
%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap.min.css">
</head>
<body>
   <%--
       window 10 => get방식으로 전송 한글이 정상
                   =====
                   URL?변수=값 
                 => get방식으로 전송 한글 깨진다
    --%>
   <div class="container">
     <h1 class="text-center"><%=chef %>님의 레시피</h1>
     <div class="row">
       <%
           for(RecipeVO vo:list)
           {
       %>
                <div class="col-md-3">
			      <div class="thumbnail">
			        <a href="#" target="_blank">
			          <img src="<%=vo.getPoster() %>" alt="Lights" style="width:100%">
			          <div class="caption">
			            <p><%=vo.getTitle() %></p>
			            <p><%=vo.getChef() %></p>
			          </div>
			        </a>
			      </div>
			    </div>
       <%
           }
       %>
     </div>
   </div>
</body>
</html>