** Spring 에서의 파라미터 처리
1. HttpServletRequest 객체의 getParameter 메소드를 호출
2. Controller의 요청 처리 메소드에 @RequestParam("파라미터 이름") 자료형 변수명 을 매개변수로 만들어서 처리
3. Command 클래스를 생성하고 Command 객체를 요청 처리 메소드의 매개변수로 이용해서 처리하는 것이 가능
** File Upload
=> File이 있는 form은 mothod 가 반드시 post방식이어야 하고 enctype을 multipart/form-data로 설정
=> pom.xml 파일에 의존성을 설정
commons-fileupload의 의존성을 설정
=> 스프링에서는 설정 파일에 MultipartResolver 클래스의 bean을 설정 파일에 등록을 해주어야 한다.
maxUploadSize 프로퍼티 : 업로드되는 파일의 최대 크기를 설정, 기본값은 -1
maxInMemorySize 프로퍼티 : 임시 파일을 생성하기 전에 메모리에 보관할 수 있는 최대크기
defaultEncoding 프로퍼티 : 인코딩 설정으로 기본값은 ISO-8859-1 인데 인코딩 필터 설정이 되어 있으면 인코딩 필터 설정을 따르게 된다.
=> Spring에서는 파일을 업로드 할 때 HttpServletRequest 대신에 MultipartHttpServletRequest 를 이용해야 하는데 이 클래스의 getFile("파라미터이름") 메소드를 호출하면 선택한 파일을 MultiPartFile이라는 자료형으로 리턴을 한다.
@RequestParam이나 Command 객체를 이용할 때는 변수의 자료형을 MultiparFile로 설정해야 한다.
=> MultipartFile 클래스
String getName() : 파라미터 이름 리턴
String getOriginFileName() : 파일의 이름을 리턴
boolean isEmpty() : 파일이 없는지 확인
long getSize() : 파일의 크기
byte [] getBytes() : 파일의 내용을 바이트 배열로 리턴
void transfer(File dest) : dest에 파일의 내용을 저장
=> 서버에 파일을 저장할 때 파일 이름을 중복되지 않도록 만들어 주어야 한다.
한명의 유저가 하나의 파일만 업로드 한다면 파일 이름을 기본키로 설정하면 된다.
여러 파일을 업로드하는 경우라면 UUID를 이용해서 유일무이한 이름을 만들어 주어야 한다.
** 파일 업로드 실습
1. pom.xml 파일에 의존성 설정
<!-- 파일 업로드 라이브러리 -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>
2. home.jsp 파일에 링크 추가
<li><a href="fileupload" class="menu">파일 업로드</a></li>
3. HomeConroller 클래스에 fileupload 요청이 post 방식
@RequestMapping(value="fileupload", method=RequestMethod.GET)
public String fileUpLoad() {
return "fileupload";
}
4. fileupload.jsp 파일을 views 디렉토리에 생성하고 작성
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>파일 업로드</title>
</head>
<body>
<form action="requestupload" method="post" enctype="multipart/form-data">
이름<input type="text" name="number" /><br/>
파일<input type="file" name="report" /><br/>
<input type="submit" value="제출" />
</form>
<form action="requestparamupload" method="post" enctype="multipart/form-data">
이름<input type="text" name="number" /><br/>
파일<input type="file" name="report" /><br/>
<input type="submit" value="제출" />
</form>
<form action="commandupload" method="post" enctype="multipart/form-data">
이름<input type="text" name="number" /><br/>
파일<input type="file" name="report" /><br/>
<input type="submit" value="제출" />
</form>
</body>
</html>
5. web.xml 파일에 파라미터 인코딩 필터 설정을 확인하고 없으면 추가
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>
org.springframework.web.filter.CharacterEncodingFilter
</filter class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
6. servlet-context.xml 파일에 MultipartResolver 클래스의 bean을
<!-- 파일 업로드 처리를 위한 bean -->
<beans:bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
</beans:bean>
7. HomeController 클래스에 첫번째 폼의 전송요청을 처리하는 메소드를 작성
=> MultipartHttpServletRequest클래스를 이용
@RequestMapping(value="requestupload", method=RequestMethod.POST)
public String UpLoad(MultipartHttpServletRequest request) {
//파라미터 읽어오기
String number = request.getParameter("number");
MultipartFile report = request.getFile("report");
//출력
System.out.println("number:" + number);
System.out.println("filename:" + report.getOriginalFilename());
return "redirect/";
}
8. HomeController 클래스에 두번째 폼의 전송 요청을 처리하는 메소드를 작성
@RequestMapping(value="requestparamupload", method=RequestMethod.POST)
public String UpLoad(@RequestParam("number") String number, @RequestParam("report") MultipartFile report) {
//파라미터 읽어오기
//출력
System.out.println("number:" + number);
System.out.println("filename:" + report.getOriginalFilename());
return "redirect/";
}
9. Command 객체 이용
1) 파라미터를 저장할 DTO 클래스를 이용
package kr.co.pk.item.domain;
import org.springframework.web.multipart.MultipartFile;
public class Command {
private String number;
private MultipartFile report;
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public MultipartFile getReport() {
return report;
}
public void setReport(MultipartFile report) {
this.report = report;
}
@Override
public String toString() {
return "Command [number=" + number + ", report=" + report + "]";
}
}
2) HomeController 클래스에 세번째 폼 처리 메소드를 생성
@RequestMapping(value="commmandupload", method=RequestMethod.POST)
public String upLoad(Command command) {
//출력
System.out.println("number:" + command.getNumber());
System.out.println("filename:" + command.getReport().getOriginalFilename());
return "redirect/";
}
** 회원관리
1. 데이터베이스 접속해서 회원테이블을 생성하고 샘플 데이터를 작성
CREATE TABLE SPRINGUSER(
EMAIL VARCHAR2(100)PRIMARY KEY,
PW VARCHAR2(100)not null,
NICKNAME VARCHAR2(100)not null,
IMAGE VARCHAR2(200) DEFAULT 'default.jpg',
REGDATE DATE DEFAULT sysdate,
LOGINDATE DATE DEFAULT sysdate,
EMAILAUTH NUMBER(1) DEFAULT 0
);
-- 샘플 데이터틑 이메일 중복검사와 닉네임 중복검사가 제대로 수행되는지 확인하기 위해서 삽입
INSERT INTO SPRINGUSER(EMAIL, PW, NICKNAME) values('ggangpae1@gmail.com', '123456', '군계')
COMMIT;
SELECT * FROM SPRINGUSER;
2. Spring MVC Project 생성
=> portfolio : kr.co.nfl
3. 프로젝트를 위한 의존성을 설정
=> java version, spring version, junit version, servlet version, jsp version은 수정
1) properties 변경
<properties>
<java-version>1.8</java-version>
<org.springframework-version>5.0.7.RELEASE</org.springframework-version>
<org.aspectj-version>1.6.10</org.aspectj-version>
<org.slf4j-version>1.6.6</org.slf4j-version>
</properties>
2) dependencies
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
3) build 태그 안의 plug in 중에서 자바 버전을 나태내는
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.5.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
실행해보면 Hello world 출력됨
4. 필요한 의존성 설정
=> oracle, spring-jdbc, spring-test, mybatis, mybatis-spring, jbcrypt, commons-fileupload, json
=> mysql, spring-orm, hibernate
1) Oracle을 위해서 Repositories를 추가
dependencies 위에 추가
<repositories>
<repository>
<id>oracle</id>
<name>ORACLE JDBC Repository</name>
<url>http://maven.jahia.org/maven2</url>
</repository>
</repositories>
2) dependencies 그냥 한방에
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>gmail.ggangpae1</groupId>
<artifactId>portfolio</artifactId>
<name>portfolio</name>
<packaging>war</packaging>
<version>1.0.0-BUILD-SNAPSHOT</version>
<properties>
<java-version>1.8</java-version>
<org.springframework-version>5.0.7.RELEASE</org.springframework-version>
<org.aspectj-version>1.6.10</org.aspectj-version>
<org.slf4j-version>1.6.6</org.slf4j-version>
</properties>
<repositories>
<repository>
<id>oracle</id>
<name>ORACLE JDBC Repository</name>
<url>http://maven.jahia.org/maven2</url>
</repository>
</repositories>
<dependencies>
<!-- 비밀번호 암호화를 위한 라이브러리 -->
<dependency>
<groupId>org.mindrot</groupId>
<artifactId>jbcrypt</artifactId>
<version>0.4</version>
</dependency>
<!-- 파일 업로드 라이브러리 -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>
<!-- XML 출력을 위한 라이브러리 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-oxm</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.1</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.2.11</version>
</dependency>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-core</artifactId>
<version>2.2.11</version>
</dependency>
<!-- json 출력을 위한 라이브러리 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.7</version>
</dependency>
<!-- PDF 출력을 위한 의존성 -->
<dependency>
<groupId>com.lowagie</groupId>
<artifactId>itext</artifactId>
<version>2.1.7</version>
</dependency>
<!-- Excel 출력을 위한 의존성 -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>3.16</version>
</dependency>
<!-- MySQL 의존성 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.49</version>
</dependency>
<!-- Oracle -->
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc7</artifactId>
<version>12.1.0.2</version>
</dependency>
<!-- MyBatis 관련 의존성 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.2</version>
</dependency>
<!-- Hibernate -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>5.4.2.Final</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- DTO를 편리하게 생성해 줄 수 있도록 해주는 라이브러리 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.8</version>
</dependency>
<!-- 데이터베이스 로그를 자세하게 기록해주는 라이브러리 -->
<dependency>
<groupId>org.bgee.log4jdbc-log4j2</groupId>
<artifactId>log4jdbc-log4j2-jdbc4</artifactId>
<version>1.16</version>
</dependency>
<!-- 스프링 테스트 라이브러리 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework-version}</version>
<exclusions>
<!-- Exclude Commons Logging in favor of SLF4j -->
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- AspectJ -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>${org.aspectj-version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${org.slf4j-version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.15</version>
<exclusions>
<exclusion>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
</exclusion>
<exclusion>
<groupId>javax.jms</groupId>
<artifactId>jms</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jdmk</groupId>
<artifactId>jmxtools</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jmx</groupId>
<artifactId>jmxri</artifactId>
</exclusion>
</exclusions>
<scope>runtime</scope>
</dependency>
<!-- @Inject -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!-- Test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<additionalProjectnatures>
<projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
</additionalProjectnatures>
<additionalBuildcommands>
<buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
</additionalBuildcommands>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.5.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.2.1</version>
<configuration>
<mainClass>org.test.int1.Main</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>
5. web.xml 파일에 파라미터 인코딩 필터 설정 추가
<!-- 파라미터 인코딩 필터 설정 -->
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>
org.springframework.web.filter.CharacterEncodingFilter
</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
6. servlet-context.xml 파일에 기본 설정 추가
<!-- Controller 가 처리하지 못하는 요청을 WAS가 처리하도록 해주는 설정 -->
<default-servlet-handler/>
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<annotation-driven />
<resources mapping="/resources/**" location="/resources/" />
<!-- Controller 에서 jsp로 포워딩하고자 할 때 사용하는 뷰 리졸버 -->
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/WEB-INF/views/" />
<beans:property name="suffix" value=".jsp" />
<beans:property name="order" value = "1" />
</beans:bean>
<!-- jsp를 제외한 출력을 위한 설정 -->
<beans:bean class="org.springframework.web.servlet.view.BeanNameViewResolver">
<beans:property name="order" value="0" />
</beans:bean>
<context:component-scan base-package="gmail.ggangpae1.portfolio" />
<!-- Controller가 처리하지 못하는 요청을 WAS 가 처리하도록 해주는 설정 -->
<default-servlet-handler/>
<!-- 파일업로드를 위한 설정 -->
<beans:bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<beans:property name="maxUploadSize"
value="10000000"/>
</beans:bean>
</beans:beans>
=> spring 설정파일을 변경하면 재실행을 헤보자.
7. 데이터베이스 접속 설정
=> applicationContext.xml(root-context.xml) 파일에 DataSource 클래스의 bean을 이용해서 데이터베이스 접속 정보를 설정
1) root-context.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 https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 데이터베이스 접속 정보를 저장하는 bean을 생성 데이터베이스 종류 별로 다르게 설정 -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>oracle.jdbc.driver.OracleDriver</value>
</property>
<property name="url">
<value>jdbc:oracle:thin:@localhost:1521:xe</value>
</property>
<property name="username">
<value>user05</value>
</property>
<property name="password">
<value>user05</value>
</property>
</bean>
</beans>
2) src/test/java 에 테스트 클래스를 생성해서 연결을 테스트
package kr.co.nfl;
import javax.sql.DataSource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
//Spring에서 JUnit4 라이브러리를 사용하기 위한 설정
@RunWith(SpringJUnit4ClassRunner.class)
//locations에 설정된 파일들을 실행시켜서 메모리에 로드하기 위한 설정
//프레임워크마다 설정 파일의 경로가 다르므로 web.xml 에 설정된 애용을 확인하고
@WebAppConfiguration
@ContextConfiguration(locations= {"file:src/main/webapp/WEB-INF/spring/**/*.xml"})
public class PorfolioTest {
//데이터베이스 연결을 확인핼 때 주입
@Autowired
private DataSource dataSource;
//연결 테스트를 위한 메소드
@Test
public void connectTest() {
try {
System.out.println(dataSource.getConnection());
}catch(Exception e) {
System.out.println(e.getMessage());
}
}
}우클릭 Run as JUnit 해보자.
데이터베이스 접속설정 완료
8. xml을 이용해서 MyBatis를 사용할 때 설정
1) 매퍼 파일을 저장할 디렉토리를 생성 - src/main/resources 에 mappers라고 생성
=> 매퍼 파일이 저장되는 디렉토리에는 매퍼파일만 존재해야 한다.
2) root-context.xml 파일에 MyBatis 설정을 추가 : tx 네임스페이 추가
=> 트랜잭션을 사용하는 경우 root-context.xml 파일에 만들면 에러가 발생하는 경우가 있다.
이런 경우에는 이 설정을 servlet-context.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"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
<!-- 데이터베이스 접속 정보를 저장하는 bean을 생성 데이터베이스 종류 별로 다르게 설정 -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>oracle.jdbc.driver.OracleDriver</value>
</property>
<property name="url">
<value>jdbc:oracle:thin:@192.168.0.200:1521:xe</value>
</property>
<property name="username">
<value>user05</value>
</property>
<property name="password">
<value>user05</value>
</property>
</bean>
<!-- MyBatis 설정 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="mapperLocations" value="mappers/**/*/xml"/>
</bean>
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
<!-- 트랜잭션 사용을 위한 부분 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
9. 하나의 서비스를 위한 기본 구조
=> mapper 파일 1개
=> DTO 클래스, DAO 클래스, Service 인터페이스, ServiceImpl클래스, Controller 클래스(웹페이지만 만들 때는 일반 컨트롤러 1개, 모바일을 위한 서버를 만들 때는 RestController1개, 웹페이와 모바일을 위한 서버를 만들 때는 일반컨트롤러1개 그리고 RestController1개 )
=> 웹페이지를 만들 때는 css를 위한 디렉토리, js를 위한 디렉토리, 리소스를 위한 디렉토리, 뷰를 위한 디렉토리를 각각 생성 - 뷰를 제외한 자원들은 webapp 디렉토리 안에 서비스 이름으로 디렉토리를 만들고 그 안에 다시 디렉토리들을 만들어서 분류
1) SpringUser 관련 데이터베이스 작업을 처리할 mapper 파일을 생성 src/main/resources안에
=> mappers/springuser.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">
<mapper namespace="springuser">
</mapper>
2) DTO 클래스 생성
=> 기본 패키지.domain.SpringUser
package kr.co.nfl.domain;
import java.util.Date;
public class SpringUser {
private String email;
private String pw;
private String nickname;
private String image;
private Date regdate;
private Date logindate;
private int emailauth;
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getPw() {
return pw;
}
public void setPw(String pw) {
this.pw = pw;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public String getImage() {
return image;
}
public void setImage(String image) {
this.image = image;
}
public Date getRegdate() {
return regdate;
}
public void setRegdate(Date regdate) {
this.regdate = regdate;
}
public Date getLogindate() {
return logindate;
}
public void setLogindate(Date logindate) {
this.logindate = logindate;
}
public int getEmailauth() {
return emailauth;
}
public void setEmailauth(int emailauth) {
this.emailauth = emailauth;
}
@Override
public String toString() {
return "SpringUser [email=" + email + ", pw=" + pw + ", nickname=" + nickname + ", image=" + image
+ ", regdate=" + regdate + ", logindate=" + logindate + ", emailauth=" + emailauth + "]";
}
}
3. DAO 클래스 생성
=> bean을 자동 생성하도록 하고 사용할 데이터베이스 연동 프레임워크의 bean을 자동으로 주입
=> 기본패키지.dao.SpringUserDAO
package kr.co.nfl.dao;
import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository
public class SpringUserDAO {
@Autowired
private SqlSession sqlSession;
}
4) Service 인터페이스 생성
=> 기본패키지.service.SpringUserService
package kr.co.nfl.service;
public interface SpringUserService {
}
5) ServiceImpl 클래스를 생성
=> Service 인터페이스를 구현(implements)
=> bean을 자동 생성하도록 해주고 DAO를 주입
package kr.co.nfl.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import kr.co.nfl.dao.SpringUserDAO;
@Service
public class SpringUserServiceImpl implements SpringUserService {
@Autowired
private SpringUserDAO springUserDao;
}
6) 웹 사이트에서 페이지 이동에 사용할 Controller를 생성
=> 기본패키지.SpringUserPageController
package kr.co.nfl;
import org.springframework.stereotype.Controller;
//웹 사이트의 페이지 이동에만 사용하는 컨트롤러
@Controller
public class SpringUserPageController {
}
7) 데이터를 제공하기 위한 Controller를 생성
=> Service를 주입받아야 한다.
=> 기본패키지.SpringUserRestController
package kr.co.nfl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;
import kr.co.nfl.service.SpringUserService;
@RestController
public class SpringUserRestController {
@Autowired
private SpringUserService springUserService;
}
8) 필요한 디렉토리를 생성
=> views 디렉토리에 회원관련 작업을 표시할 view들을 저장할 user 디렉토리를 생성 (웹페이지 안만들꺼면 필요없다)
=> webapp 디렉토리에 user 디렉토리를 생성하고 그 안에 js, css, profile(이미지 저장) 디렉토리를 생성
=> 실제 업무에서는 이미지와 같은 파일들은 다른 컴퓨터에 저장
10. 회원가입
=> 회원가입 요청을 하면 회원정보를 입력할 화면으로 이동을 하고 정보를 입력한 후 다시 회원가입을 요청하면 가입요청을 처리
=> 가입 요청을 처리할 때 primary key나 unique가 있는 중복 검사를 수행해야 하고 not null이 있으면 데이터가 있는지 확인을 해야 한다.
=> 파일도 같이 전송하기 때문에 파일 업로드도 처리해 주어야 한다.
=> email의 경우 복호화가 가능한 암호화 방식으로 저장할 것이고 pw의 경우는 복호화가 불가능하고 비교만 가능하도록 저장
1) default.jpg 파일을 profile 디렉토리에 복사해놓기.
2) 데이터 암호화와 복호화를 위한 CryptoUtil.java를 프로젝트에 복사
=> kr.co.nfl.util
3) home.jsp 파일에 회원가입 링크를 추가
자동생성되어 있는건 지우고 다시 생성
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>포트폴리오</title>
</head>
<body>
<a href="user/join">회원가입</a><br/>
</body>
</html>
4)
package kr.co.nfl;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
//웹 사이트의 페이지 이동에만 사용하는 컨트롤러
@Controller
public class SpringUserPageController {
@RequestMapping(value="user/join", method=RequestMethod.GET)
public String join() {
return "user/join";
}
}
5)
6) join.css
ul {
list-style-type: none;
}
ul li {
clear: both;
}
form {
width: 50em;
border: 1px solid #666;
border-radius: 10px;
box-shadow: .2em .2em .5em #999;
background-color: #d0e9f6;
padding: 1em;
overflow: hidden;
}
label {
display: block;
float: left;
width: 10em;
text-align: right;
margin-right: .5em;
color: #04699d;
}
input.textinput {
width: 30em;
height: 2em;
border: 1px solid #666;
margin-bottom: 1em;
display: block;
float: left;
}
input.fileinput {
width: 15em;
height: 2em;
border: 1px solid #666;
margin-bottom: 1em;
margin-right: 1em;
display: block;
float: left;
}
img {
width: 7em;
height: 7em;
border: 1px solid #666;
margin-bottom: 1em;
}
textarea {
display: block;
width: 30em;
height: 5em;
border: 1px solid #666;
margin-bottom: 1em;
line-height: 1.25;
overflow: auto;
resize: none;
}
input.textinput, textarea {
font-family: Georgia, "Times New Roman", Times, serif;
font-size: .875em;
}
input[type="submit"], input[type="button"] {
display: block;
width: 10em;
height: 2em;
float: left;
background: white;
font-size: inherit;
border: 1px solid #04699d;
border-radius: 4px;
box-shadow: 2px 2px 3px rgba(0, 0, 0, .5);
margin-top: 1em;
margin-right: 1em;
color: #C00;
}
input[type="submit"] {
margin-left: 5em;
}
div {
color: red;
clear: both;
margin-left: 11em;
margin-bottom: 1em;
}
/* 화명크기나 디바이스 종류별로 CSS를 적용하기 위한 방법, 이 방법을 이용해서 반응형 웹 디자인을 구현한다 */
@media screen and (max-width: 960px) {
form {
width: 20em;
border: 1px solid #666;
border-radius: 10px;
box-shadow: .2em .2em .5em #999;
background-color: #d0e9f6;
padding: 1em;
overflow: hidden;
}
label {
display: block;
float: left;
width: 4em;
text-align: right;
margin-right: .5em;
color: #04699d;
}
input.textinput {
width: 13em;
height: 2em;
border: 1px solid #666;
margin-bottom: 1em;
}
img {
width: 7em;
height: 7em;
border: 1px solid #666;
margin-bottom: 1em;
margin-left: 5em;
}
textarea {
display: block;
width: 13em;
height: 5em;
border: 1px solid #666;
margin-bottom: 1em;
line-height: 1.25;
overflow: auto;
resize: none;
}
input.textinput, textarea {
font-family: Georgia, "Times New Roman", Times, serif;
font-size: .875em;
}
input[type="submit"], input[type="button"] {
display: block;
width: 10em;
height: 2em;
float: left;
background: white;
font-size: inherit;
border: 1px solid #04699d;
border-radius: 4px;
box-shadow: 2px 2px 3px rgba(0, 0, 0, .5);
margin-top: 1em;
color: #C00;
margin-left: 3em;
}
}여기까지는 웹
7) springuser.xml 파일에 회원가입에 필요한 SQL을 작성
=> email 중복체크, nickname 중복체크, 회원가입을 위한 SQL
<?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">
<mapper namespace="springuser">
<!-- springuser 테이블의 email 중복체크를 위한 SQL -->
<!-- email에 해당하는 데이터 찾아오기 -->
<select id="emailcheck" parameterType="java.lang.String" resultType="java.lang.String">
select email
from springuser
where email = #{email}
</select>
<!-- nickname 중복체크를 위한 SQL -->
<select id="nicknamecheck" parameterType="java.lang.String" resultType="java.lang.String">
select nickname
from springuser
where nickname = #{nickname}
</select>
<!-- 회원가입을 처리하는 SQL -->
<insert id="join" parameterType="kr.co.nfl.domain.SpringUser">
insert into springuser(email, pw, nickname, image)
value(#{email}, #{pw}, #{nickname}, #{image})
</insert>
</mapper>
8) Test 클래스에서 SQL 테스트
package kr.co.nfl;
import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import kr.co.nfl.domain.SpringUser;
//Spring에서 JUnit4 라이브러리를 사용하기 위한 설정
@RunWith(SpringJUnit4ClassRunner.class)
//locations에 설정된 파일들을 실행시켜서 메모리에 로드하기 위한 설정
//프레임워크마다 설정 파일의 경로가 다르므로 web.xml 에 설정된 애용을 확인하고
@WebAppConfiguration
@ContextConfiguration(locations= {"file:src/main/webapp/WEB-INF/spring/**/*.xml"})
public class PorfolioTest {
//데이터베이스 연결을 확인핼 때 주입
@Autowired
private DataSource dataSource;
//연결 테스트를 위한 메소드
@Test
public void connectTest() {
try {
System.out.println(dataSource.getConnection());
}catch(Exception e) {
System.out.println(e.getMessage());
}
}
@Autowired
private SqlSession sqlSession;
@Test
public void sqlTest() {
//email 중복검사
//존해하는 이메일이므로 이메일이 출력
System.out.println(sqlSession.selectOne("springuser.emailcheck", "ggangpae1@gmail.com"));
//없는 이메일이므로 null 출력
System.out.println(sqlSession.selectOne("springuser.emailcheck", "sblee5212@gmail.com"));
System.out.println(sqlSession.selectOne("springuser.nicknamecheck","군계"));
//없는 닉네임이므로 null 출력
System.out.println(sqlSession.selectOne("springuser.nicknamecheck", "관리자"));
//데이터 삽입 확인
SpringUser user = new SpringUser();
user.setEmail("sblee5212@gmail.com");
user.setPw("qwe123");
user.setNickname("관리자");
user.setImage("sample.png");
//삽입 삭제 갱신은 정수를 리턴하는데 리턴되는 값은 영향받은 행의 개수
System.out.println(sqlSession.insert("srpinguser.join", user));
}
}
9) SpringUserDAO 클래스에 회원가입 관련된 메소드 작성
package kr.co.nfl.dao;
import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import kr.co.nfl.domain.SpringUser;
@Repository
public class SpringUserDAO {
@Autowired
private SqlSession sqlSession;
//이메일 중복 체크 메소드
public String emailCheck(String email) {
return sqlSession.selectOne("springuser.emailcheck", email);
}
//닉메일 중복 체크 메소드
public String nicknameCheck(String nickname) {
return sqlSession.selectOne("springuser.nicknamecheck", nickname);
}
//회원가입 처리 메소드
public int join(SpringUser springUser) {
return sqlSession.insert("springuser.join", springUser);
}
}
10) SpringUserService 인터페이스에 회원가입 처리를 위한 메소드를 선언
=> 결과를 Map으로 리턴해서 그 결과를 json 형식으로 출력할 수 있도록 만들어야 한다.
=> Map을 확인하면 작업이 어떻게 되었는지 알 수 있어야 한다.
result 같은 속성을 생성해서 작업의 성공과 실패 여부를 저장해주는 것이 좋다.
실패했을 때는 왜 실패했는지 설정해 주는 것이 좋다.
package kr.co.nfl.service;
import java.util.Map;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.multipart.MultipartHttpServletRequest;
public interface SpringUserService {
//메소드의 원형은
//public Map<String, Object> 이름 (HtteServletRequest request, HttpServletRespose response)
//request를 이용해서 클라이언트의 정보를 확인할 수 있고 response를 이용해서 클라이언트에 출력을 훌 수 있다.
//파일이 업로드 되는 경우에는 HttpServletRequest 대신에 MultiparthttpServletRequest를 사용하면 된다.
//회원가입을 처리해주는 메소드
public Map<String, Object> join(MultipartHttpServletRequest request, HttpServletResponse response);
}
11) SpringUserServiceImpl 클래스에 회원가입
**암호화 방식
1. 비밀키 암호화
=> 암호화하는 키와 해독하는 키를 동일하게 설정해서 암호화
=> 암호화 키과 해독키 모두 비밀
2. 공개키 공개화
=> 암호화는 방법은 공개를 하지만 해독키는 공개하지 않는 방식
3. 공개키 암호화가 보안이 우수
package kr.co.nfl.service;
import java.io.File;
import java.io.FileOutputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import javax.servlet.http.HttpServletResponse;
import org.mindrot.jbcrypt.BCrypt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import kr.co.nfl.dao.SpringUserDAO;
import kr.co.nfl.domain.SpringUser;
import kr.co.nfl.util.CryptoUtil;
@Service
public class SpringUserServiceImpl implements SpringUserService {
@Autowired
private SpringUserDAO springUserDao;
@Override
public Map<String, Object> join(MultipartHttpServletRequest request, HttpServletResponse response) {
//결과를 저장할 객체를 생성
Map<String, Object> map = new HashMap<String, Object>();
//성공과 실패를 확인할 데이터 생성
map.put("result", false);
//실패했을 때 실패 이유를 저장하기 위한 데이터 생성
map.put("emailcheck", false);
map.put("nicknamecheck", false);
//파라미터 읽기
String email = request.getParameter("email");
String pw = request.getParameter("pw");
String nickname = request.getParameter("nickname");
//파일은 읽는 방법이 다르다.
MultipartFile mf = request.getFile("image");
//email 중복 검사 수행
String emailResult = springUserDao.emailCheck(email);
if(emailResult==null) {
map.put("emailcheck", true);
}
//nickname 중복 검사 수행
String nicknameResult = springUserDao.nicknameCheck(nickname);
if(nicknameResult == null) {
map.put("nicknamecheck", true);
}
//email 종복섬사와 nickname 중복검사를 통과한 경우에만 데이터 삽입
if(emailResult == null && nicknameResult == null) {
//그림 파일의 기본 이름 설정
String image = "default.png";
//파일을 선택한 경우에만 파일을 서버에 복사
if(mf.isEmpty() == false) {
//저장할 디렉토리 경로를 생성
String uploadPath = request.getServletContext().getRealPath("/user/profile");
//파일 이름을 랜덤하게 설정
image = UUID.randomUUID() + mf.getOriginalFilename();
//실제 저장될 경로 만들기
uploadPath = uploadPath + "/" + image;
//파일 객체생성
File file = new File(uploadPath);
FileOutputStream fos = null;
try {
//mf 의 내용을 file에 복사
fos = new FileOutputStream(file);
fos.write(mf.getBytes());
}catch(Exception e) {
System.out.println(e.getMessage());
}
}
//공개키 암호화에 사용할 키를 생성
//실무에서는 이 키를 데이터베이스에서 불러온다.
String key = "approach";
//저장할 데이터 생성
SpringUser user = new SpringUser();
try {
//email 암호화해서 저장
user.setEmail(CryptoUtil.encryptAES256(email, key));
user.setPw(BCrypt.hashpw(pw, BCrypt.gensalt()));
user.setImage(image);
//데이터베이스에 저장
int row = springUserDao.join(user);
//저장에 성공하면 map의 ㄱㄷ녀ㅣㅅdp true 저장
if(row >0) {
map.put("result", true);
}
}catch(Exception e) {
System.out.println(e.getMessage());
}
}
return map;
}
}
12) SpringUserRestController에서 회원가입 요청을 처리하는 메소드를 구현
package kr.co.nfl;
import java.util.Map;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import kr.co.nfl.service.SpringUserService;
@RestController
public class SpringUserRestController {
@Autowired
private SpringUserService springUserService;
//회원가입을 처리하는 메소드
@RequestMapping(value="join", method=RequestMethod.POST)
public Map<String, Object> join(MultipartHttpServletRequest request, HttpServletResponse response){
//서비스의 메소드를 호출
Map<String, Object> map = springUserService.join(request, response);
return map;
}
}
7번부터 여기까지는 클라이언트가 달라져도 같다.
13) join.jsp 파일의 요청을 처리하는 스크립트 코드를 join.js 파일에 작성
=> 서버로 전송하기 전에 데이터 유효성 검사를 수행하고 서버로 전송해서 결과를 받으면 그 결과를 가지고 다음행동을 작성
window.addEventListener("load", function(event){
//필요한 DOM 객체 가져오기
var joinform = document.getElementById("joinform");
var email = document.getElementById("email");
var pw = document.getElementById("pw");
var pw1 = document.getElementById("pw1");
var nickname = document.getElementById("nickname");
var image = document.getElementById("image");
var img = document.getElementById("img");
var msg = document.getElementById("msg");
var emailmsg = document.getElementById("emailmsg");
var pwmsg = document.getElementById("pwmsg");
var nicknamemsg = document.getElementById("nicknamemsg");
var joinbtn = document.getElementById("joinbtn");
var mainbtn = document.getElementById("mainbtn");
var loginbtn = document.getElementById("loginbtn");
//mainbtn 과 loginbtn을 눌렀을 때 페이지 이동
mainbtn.addEventListener("click", function(event){
location.href="../";
});
loginbtn.addEventListener("click", function(event){
location.href="login";
});
//이미지 미리보기
image.addEventListener("change", function(event){
//선택한 파일이 있다면
if(this.files && this.files[0]){
//파일 읽기 객체 생성
var reader = new FileReader();
//파일 읽기 요청
reader.readAsDataURL(this.files[0]);
//자바스크립트에서 파일을 읽는 것은 비동기
reader.addEventListener("load", function(e){
img.src = e.target.result;
});
}
});
//회원가입 버튼을 눌렀을 때 처리
var flag = false;
joinbtn.addEventListener("click", function(event){
//서버로 보내기 전에 데이터의 유효성 검사를 수행
//데이터의 길이 나 형식(정규식)을 검사
//길이를 검사할 때는 좌우 공백을 제거하고 검사를 수행
if (email.value.trim().length < 1) {
emailmsg.innerHTML = '이메일은 필수 입력입니다.<br/>';
flag = true;
} else {
var emailRegExp = /^[0-9a-zA-Z]([-_.]?[0-9a-zA-Z])*@[0-9a-zA-Z]([-_.]?[0-9a-zA-Z])*.[a-zA-Z]{2,3}$/i;
if (!emailRegExp.test(email.value.trim())) {
emailmsg.innerHTML = '잘못된 이메일 형식입니다.<br/>';
flag = true;
}
}
if (pw.value.trim().length < 1) {
pwmsg.innerHTML += '비밀번호는 필수 입력입니다.<br/>';
flag = true;
} else {
var pwRegExp = /^.*(?=^.{8,15}$)(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%^&+=]).*$/;
if (!pwRegExp.test(pw.value.trim())) {
pwmsg.innerHTML = '비밀번호는 숫자와 영문 대소문자 그리고 특수문자가 포함되어야 합니다.<br/>';
flag = true;
} else {
if (pw.value.trim() !== pw1.value.trim()) {
pwmsg.innerHTML += '2개의 비밀번호는 같아야 합니다.<br/>';
flag = true;
}
}
}
if (nickname.value.trim().length < 1) {
nicknamemsg.innerHTML += '별명은 필수 입력입니다.<br/>';
flag = true;
} else {
var nicknameRegExp = /^[a-zA-z가-힣0-9]{2,5}$/;
if (!nicknameRegExp.test(nickname.value.trim())) {
nicknamemsg.innerHTML = '닉네임은 영문 한글 숫자로 2자 이상 5자 이하이어야 합니다.<br/>';
flag = true;
}
}
if(flag == true){
return;
}
//ajax 요청 : join
var url = "join";
//ajax 객체를 생성
var request = new XMLHttpRequest();
//요청을 생성
request.open('post', url, true);
//폼데이터 생성
var formData = new FormData(joinform);
//요청을 전송
request.send(formData);
//ajax 요청에 응답이 오면
request.addEventListener("load", function(e){
alert(e.target.responseText);
});
});
});
14) 데이터베이스의 샘플 데이터를 전부 삭제
=> 이전에 저장한 데이터는 로직을 테스트하기 위한 데이터라서 암호화가 되어 있지 않다.
15) email 중복 검사 SQL 수정 - springuser.xml에서 where email = #{email} 삭제
<?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">
<mapper namespace="springuser">
<!-- springuser 테이블의 email 중복체크를 위한 SQL -->
<!-- email에 해당하는 데이터 찾아오기 -->
<select id="emailcheck" parameterType="java.lang.String" resultType="java.lang.String">
select email
from springuser
</select>
<!-- nickname 중복체크를 위한 SQL -->
<select id="nicknamecheck" parameterType="java.lang.String" resultType="java.lang.String">
select nickname
from springuser
where nickname = #{nickname}
</select>
<!-- 회원가입을 처리하는 SQL -->
<insert id="join" parameterType="kr.co.nfl.domain.SpringUser">
insert into springuser(email, pw, nickname, image)
value(#{email}, #{pw}, #{nickname}, #{image})
</insert>
</mapper>
16) SpringUserDAO 클래스의 emil 중복 검사 메소드 수정
package kr.co.nfl.dao;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import kr.co.nfl.domain.SpringUser;
@Repository
public class SpringUserDAO {
@Autowired
private SqlSession sqlSession;
//이메일 중복 체크 메소드
public List<String> emailCheck(String email) {
return sqlSession.selectOne("springuser.emailcheck", email);
}
//닉메일 중복 체크 메소드
public String nicknameCheck(String nickname) {
return sqlSession.selectOne("springuser.nicknamecheck", nickname);
}
//회원가입 처리 메소드
public int join(SpringUser springUser) {
return sqlSession.insert("springuser.join", springUser);
}
}
17) SpringUserServiceImpl의 이메일 중복 검사 수정
String emailResult = null;
//암호화 되어 있기 때문에 전체 이메일을 가져와서
//복호화 하면서 비교
List<String> emailList = springUserDao.emailCheck();
try {
for (String imsi : emailList) {
if (CryptoUtil.decryptAES256(
imsi, "itggangpae").equals(email)) {
emailResult = email;
break;
}
}
} catch (Exception e) {}