Kephi Javatory

2. Java 자바 제네릭 - 멀티 타입 파라미터( class<K, V . . . >, interface<K, V, . . .> )

kephi — Fri, 6 Nov 2020 15:05:39 +0900

제네릭 타입은 두 개 이상의 멀티 타입 파라미터를 사용할 수 있다.

이 경우 각각 타입 파라미터를 콤마로 구분한다.

예) Product.java : 제네릭 클래스

public class Product<T, M> {
    private T kind;
    private M model;
    
    public T getKind() { return this.kind; }
    public M getModel() { return this.model; }
    
    public void setKind(T kind) { this.kind = kind; }
    public void setModel(M model) { this.model = model; }
}

ProductExample.java : 제네릭 객체 생성 실행 클래스

public class ProductExample {
    public static void main(String[] args) {
        
        Product<Tv, String> product1 = new Product<Tv, String>();
        
        product1.setKind(new Tv());
        product1.setModel("스마트Tv");
        
        Tv tv = product1.getKind();
        String tvModel = product1.getModel();
        
        Product<Car, String> product2 = new Product<Car, String>();
        
        product2.setKind(new Car());
        product2.setModel("디젤");
        
        Car car = product2.getKind();
        String carModel = product2.getModel();
    }
}

제네릭 타입 변수 선언과 객체 생성을 동시에 할 때,

타입 파라미터 자리에 구체적인 타입을 지정하는 코드가 중복으로 나와서 복잡해질 수 있다.

Product<Tv, String> product = new Product<Tv, String>();

자바 7 부터 제네릭 타입 파라미터 중복 입력을 줄이기 위해 <> 연산자를 제공한다.

컴파일러는 타입 파라미터 부분에 <> 연산자를 사용하면 타입 파라미터를 유추해서 자동으로 설정한다.

Product<Tv, String> product = new Product<>();

1. Java 자바 제네릭 - 제네릭 (Generic) 타입

kephi — Fri, 6 Nov 2020 13:40:29 +0900

Java 5 부터 제네릭 (Generic) 타입이 새로 추가되었다.

제네릭을 사용해서 잘못된 타입이 사용될 수 있는 문제를 컴파일 과정에서 제거할 수 있다.

제네릭은 클래스, 인터페이스, 메소드를 정의할 때 타입(type) 을 파라미터로 사용할 수 있도록 한다.

타입 파라미터는 코드 작성 시 구체적인 타입으로 대체되어서 다양한 코드를 생성하도록 해준다.

1. 제네릭의 장점

- 컴파일 시 강한 타입 체크를 할 수 있다.

컴파일러는 코드에서 잘못 사용된 타입 때문에 발생하는 문제점을 제거하기 위해

제네릭 코드에 대해 강한 타입 체크를 한다.

실행 시 타입 에러가 나는 것보다 컴파일 시에 미리 타입을 강하게 체크해서 에러를 사전에 방지한다.

- 타입 변환(casting) 을 제거한다.

비 제네릭 코드는 불필요한 타입 변환을 하기 때문에 성능에 악영향을 미친다.

예)

List list = new ArrayList();

list.add("hello");

String str = (String) list.get(0);  // 타입 변환을 해야 한다.

아래와 같이 제네릭 코드로 수정하면 List 에 저장되는 요소를 String 타입으로 국한되기 때문에

요소를 찾아올 때 타입 변환 필요 없기 때문에 프로그램 성능이 향상된다.

예)

List<String> list = new ArrayList<String>();

List.add("hello");

String str = list.get(0);   // 타입 변환을 하지 않는다. (필요X)

2. 제네릭 타입 Class<T>, interface<T>

타입을 파라미터로 가지는 클래스와 인터페이스를 말한다.

제네릭 타입은 클래스, 인터페이스 이름 뒤에 "< >" 부호가 붙고, 사이에 타입 파라미터 T 가 위치한다.

public class 클래스명<T> { . . . }

public interface 인터페이스명<T> { . . . }

- 타입 파라미터는 변수명과 동일한 규칙에 따라 작성한다.

(일반적으로 대소문자 알파벳 한 글자로 표현)

① Object 클래스를 사용하는 경우

예) Box 클래스

public class Box {
    private Object object;
    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

Object 타입 선언 : 필드에 모든 종류의 객체를 저장하려는 의도.

Object 클래스는 모든 자바 클래스의 최상위 클래스이다.

따라서 자식 객체는 부모 타입에 대입할 수 있다는 성질을 통해 모든 자바 객체는

Object 타입으로 자동 타입 변환되어 저장된다.

Object object = 자바 모든 객체;

set() 메소드는 매개 변수 타입으로 Object 를 사용함으로써 자바의 모든 객체를 받을 수 있고,

받은 매개값을 Object 필드에 저장시킨다.

get() 메소드는 Object 필드에 저장된 객체를 Object 타입으로 리턴한다.

만약 필드에 저장된 원래 타입의 객체를 얻으려면,

아래와 같이 강제 타입 변환을 해야 한다.

Box box = new Box();

box.set("hello");   // String 타입을 Object 타입으로 자동 타입 변환해서 저장

String str = (String) box.get();  // Object 타입을 String 타입으로 강제 타입 변환해서 얻음

Object 타입을 String 타입으로 강제 타입 변환을 해서 얻어야 한다.

예) Box.java : Box 클래스

public class Box {
    private Object object;
    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

Apple.java : Apple 클래스

public class Apple {
}

BoxExample.java : 비 제네릭 타입 이용 실행 클래스

public class BoxExample {
    public static void main(String[] args) {
        Box box = new Box();
        
        box.set("홍길동");                   // String -> Object 자동 타입 변환
        String name = (String) box.get();    // Object -> String 강제 타입 변환
        
        box.set(new Apple());                // Apple -> Object 자동 타입 변환
        Apple apple = (Apple) box.get();     // Object -> Apple 강제 타입 변환
    }
}

Object 타입을 사용하면 모든 종류의 자바 객체를 저장할 수 있는 장점이 있지만,

저장할 때 타입 변환이 발생, 읽어올 때도 타입 변환이 발생한다.

이러한 타입 변환이 빈번해지면 전체 프로그램 성능에 악영향을 미치게된다.

② 제네릭 사용

Box.java

public class Box<T> {
    private T t;
    public T get() { return t; }
    public void set(T t) { this.t = t; }
}

타입 파라미터를 사용해서 Object 타입을 모두 T 로 대체했다.

T 는 Box 클래스로 객체를 생성할 때 구체적인 타입으로 변경된다.

Box<String> box = new Box<String>(); // Box 객체 생성

타입 파라미터 T 는 String 타입으로 변경되어 Box 클래스의 내부는 아래와 같이 자동으로 재구성된다.

public class Box<String> {
    private String t;
    public void set(String t) { this.t = t; }
    public String get() { return t; }
}

필드 타입이 String 으로 변경되었고, set() 메소드도 String 타입만 매개값으로 받을 수 있게 변경되었다.

get() 메소드 역시 String 타입으로 리턴하도록 변경된다.

따라서 아래 코드를 실행하면 타입 변환이 전혀 발생하지 않는다.

Box<String> box = new Box<String>();

box.set("hello");

String str = box.get();

만약 아래와 같이 Box 객체를 생성한다면??

Integer 는 int 값에 대한 객체 타입으로 자바에서 제공하는 표준 API 이다. (래퍼 객체)

Box<Integer> box = new Box<Integer>();

타입 파라미터 T 는 Integer 타입으로 변경되어 Box 클래스는 내부적으로 아래와 같이 자동으로 재구성된다.

public class Box<Integer> {
    private Integer t;
    public void set(Integer t) { this.t = t; }
    public Integer get() { return t; }
}

필드 타입 : Integer 로 변경

set() 메소드의 매개값 타입 : Integer 로 변경

get() 메소드의 리턴 타입 : Integer 로 변경

따라서 아래 코드를 실행하면 타입 변환이 전혀 발생하지 않는다.

Box<Integer> box = new Box<Integer> {
    private Integer t;
    public void set(Integer t) { this.t = t; }
    public Integer get() { return t; }
}

제네릭은 클래스를 설계할 때 구체적인 타입을 명시하지 않고, 타입 파라미터로 대체했다가,

실제 클래스가 사용될 때 (객체 생성 시) 구체적인 타입을 지정함으로써 타입 변환을 최소화한다.

예)

Box.java : 제네릭 타입

public class Box<T> {
    private T t;
    public T get() { return t; }
    public void set(T t) { this.t = t }
}

BoxExample.java : 제네릭 타입 이용 실행 클래스

public class BoxExample {
    public static void main(String[] args) {
        Box<String> box1 = new Box<String>();
        box1.set("hello");
        String str = box1.get();
        
        Box<String> box2 = new Box<Integer>();
        box2.set(6);
        
        int value = box2.get();
    }
}

JSP - 서블릿 4. URL 패턴 매핑 규칙

kephi — Mon, 2 Nov 2020 09:21:27 +0900

web.xml 의 <servlet-mapping> 태그는 <url-pattern> 태그를 사용해서 서블릿과 URL을 매핑하고,

@WebServlet 일 때는 urlPatterns 속성을 이용해서 서블릿과 URL을 매핑한다.

<url-pattern> 태그와 urlPatterns 속성에서 사용할 수 있는 URL 패턴 규칙

- '/' 으로 시작하고 '/*' 로 끝나는 url-pattern 은 경로 매핑을 위해서 사용한다.

- '*.' 으로 시작하는 url-pattern 은 확장자에 대한 매핑을 할 때 사용한다.

- 오직 '/' 만 포함하는 경우, 어플리케이션의 기본 서블릿으로 매핑한다.

- 이 규칙 외, 나머지 다른 문자열은 정확한 매핑을 위해 사용한다.

예) 아래 표처럼 서블릿이 매핑 되었을 때...

URL 패턴	매핑된 서블릿
/foo/bar/*	servlet1
/baz/*	servlet2
/catalog	servlet3
*.bop	servlet4

위와 같이 URL 패턴을 설정할 경우, 실제 요청 경로에 따라 요청이 처리되는 서블릿은 아래와 같다.

요청 경로	일치 되는 URL 패턴	요청 처리 서블릿
/foo/bar/index.html	/foo/bar/*	servlet1
/foo/bar/index.bop	/foo/bar/*	servlet1
/baz	/baz/*	servlet2
/baz/index.html	/baz/*	servlet2
/catalog	/catalog	servlet3
/catalog/racecar.bop	*.bop	servlet4
/index.bop	*.bop	servlet4

JSP - 서블릿 2. 서블릿 로딩과 초기화(init())

kephi — Mon, 2 Nov 2020 08:43:28 +0900

예) NowServlet 코드

public class NowServlet extends HttpServlet {
    
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
            response.setContentType("text/html; charset=utf-8");
            
            PrintWriter out = response.getWriter();
            ... 코드 생략
            
            out.println("</body></html>");
    }
}

앞서 web.xml에서 NowServlet 을 /now 경로에 매핑했다.

/now 경로로 접근하면 NowServlet 을 실행하는데,

서블릿 컨테이너는 처음 서블릿을 실행할 때 서블릿 객체를 생성한다.

즉, 서블릿을 최초 요청할 때 서블릿 객체를 생성하고,

이후 요청이 오면 앞서 생성한 서블릿 객체를 그대로 사용한다.

서블릿 로딩 과정

서블릿 로딩 과정 : 웹 컨테이너가 서블릿 객체를 생성하고 init() 메소드를 호출하는 과정

서블릿은 init() 메소드를 사용해서 필요한 초기화 작업을 수행한다.

init() 메소드의 기본 구현

//GenericServlet 구현
public void init(ServletConfig config) throws ServletException {
    this.config = config;
    this.init();
}

public void init() throws ServletException {
}

서블릿 컨테이너는 서블릿을 초기화하기 위해 ServletConfig 파라미터를 갖는 init() 메소드를 실행한다.

init(ServletConfig) 메소드는 내부에서 다시 파라미터가 없는 init() 메소드를 호출한다.

따라서 초기화가 필요한 서블릿은 파라미터가 없는 init() 메소드를 재정의하면 된다.

(ServletConfig 이 필요하면, ServletConfig를 파라미터로 갖는 init() 메소드를 재정의하면 된다.)

예) DBCPInit.java 에서 파라미터가 없는 init() 메소드를 재정의함

public class DBCPInit extends HttpServlet {

    @Override
    public void init() throws ServletException {   // 서블릿을 초기화 할 때 사용
        loadJDBCDriver();
        initConnectionPool();
    }
    ...
}

보통 초기화 작업은 상대적으로 시간이 오래 걸리기 때문에,

처음 서블릿을 사용하는 시점보다 웹 컨테이너를 처음 구동시키는 시점에 초기화를 진행하는 것이 좋다.

이를 위한 설정이 web.xml 의 <load-on-startup> 태그이다.

예) web.xml 에서 DBCP 초기화를 위한 설정 (jdbc 패키지의 DBCPInit 서블릿)

<servlet>
    <servlet-name>DBCPInit</servlet-name>
    <servlet-class>jdbc.DBCPInit</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>

<load-on-startup> 태그를 설정하면 웹 어플리케이션을 시작할 때 서블릿을 로딩한다.

즉, 톰캣을 구동하는 시점에서 DBCPInit 서블릿 객체를 생성하고, init() 메소드를 실행한다.

웹 어플리케이션을 시작하는 시점에서 커넥션 풀을 초기화하므로,

JSP 나 서블릿 코드에서 커넥션 풀을 사용할 수 있게 된다.

<load-on-startup> 태그로 서블릿을 미리 초기화

<load-on-startup> 태그의 값은 로딩 순서를 의미한다.

값을 기준으로 오름차순으로 서블릿을 로딩한다.

예) 값이 적은 Config 서블릿(1) 을 로딩하고, DBCPInit 서블릿(2) 을 로딩한다.

<servlet>
    <servlet-name>Config</servlet-name>
    <servlet-class>config.ConfigInit</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet>
    <servlet-name>DBCPInit</servlet-name>
    <servlet-class>jdbc.DBCPInit</servlet-class>
    <load-on-startup>2</load-on-startup>
</servlet>

만약 @WebServlet 어노테이션을 사용하는 경우에는 loadOnStartup 속성을 이용해서 로딩 값을 지정한다.

@WebServlet(urlPatterns = "/hello", loadOnStartup = 1)
public class InitServlety extends HttpServlet {
    . . . 
}

JSP - 서블릿 3. 초기화 파라미터

kephi — Sun, 1 Nov 2020 23:42:09 +0900

DBCPInit.java 코드의 일부분

public class DBCPInit extends HttpServlet {

    @Override
    public void init() throws ServletException {
        loadJDBCDriver();
        initConnectionPool();
    }
    
    private void loadJDBCDriver() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException ex) {
            throw new RuntimeException("fail to load JDBC Driver", ex);
        }
    }
    
    private void initConnectionPool() {
        try {
            String jdbcUrl = "jdbc:mysql://localhost:3306/chap14?" + 
                             "useUnicode=true&characterEncoding=utf8";
            String username = "root";
            String pw = "db비밀번호";
            
            ... 코드 생략
    }
}

위의 DBCPInit 클래스의 단점!!

- JDBC 드라이버 클래스 이름 ("com.mysql.jdbc.Driver");

- JDBC URL (jdbcUrl)

- DB 사용자 정보 (username, pw)

코드들이 들어가 있기 때문에 DB를 MySQL 에서 오라클 DB 등으로 변경할 때 직접 코드를 수정해야 한다.

초기화 파라미터를 사용하면, 서블릿 코드를 직접 변경하지 않고 사용할 값을 변경할 수 있다.

web.xml 의 <init-param> 태크를 사용해서 서블릿을 초기화할 때 필요한 값을 전달하는 방법을

제공하고 있다.

<init-param> 태크는 서블릿 초기화 파라미터를 지정할 때 사용되며 자식 태그는 아래와 같다.

- <param-name> 태그 : 초기화 파라미터의 이름을 지정한다.

- <param-value> 태그 : 초기화 파라미터의 값을 지정한다.

<servlet>
    <servlet-name>DBCPInit2</servlet-name>
    <servlet-class>jdbc.DBCPInit2</servlet-class>
    <init-param>
        <param-name>jdbcdriver</param-name>
        <param-value>com.mysql.jdbc.Driver</param-value>
    </init-param>
    
    <init-param>
        <param-name>poolName</param-name>
        <param-value>chap14</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

위 코드는 jdbcDriver 이름의 초기화 파라미터 값으로 com.mysql.jdbc.Driver 를 지정,

poolName 초기화 파라미터 값으로 chap14 지정 한다.

서블릿 클래스에서 초기화 파라미터에 접근하려면 getInitParameter() 메소드를 사용한다.

초기화 파라미터를 사용해서 커넥션 풀과 관련된 설정 정보를 전달받도록 구현한다.

chap17/src/jdbc/DBCPInit2.java : 초기화 파라미터 사용

package jdbc;

import java.sql.DriverManager;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;

import org.apache.commons.dbcp2.ConnectionFactory;
import org.apache.commons.dbcp2.DriverManagerConnetionFactory;
import org.apache.commons.dbcp2.PoolableConnection;
import org.apache.commons.dbcp2.PoolableConnectionFactory;
import org.apache.commons.dbcp2.PoolingDriver;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

public class DBCPInit2 extends HttpServlet {

    @Override
    public void init() throws ServletException {
        loadJDBCDriver();
        initConnectionPool();
    }
    
    private void loadJDBCDriver() {
        String driverClass = getInitParameter("jdbcdriver");  // jdbcdriver 초기화 파라미터
        try {
            Class.forName(driverClass);
        } catch (ClassNotFoundException ex) {
            throw new RuntimeException("fail to load JDBC Driver", ex);
        }
    }
    
    private void initConnectionPool() {
        try {
            String jdbcUrl = getInitParameter("jdbcUrl");  // jdbcUrl 초기화 파라미터
            String username = getInitParameter("dbUser");  // dbUser 초기화 파라미터
            String pw = getInitParameter("dbPass");  // dbPass 초기화 파라미터
            
            ConnectionFactory connFactory =
                new DriverManagerConnectionFactory(jdbcUrl, username, pw);
            
            PoolableConnectionFactory poolableConnFactory =
                new PoolableConnectionFactory(connFactory, null);
            poolableConnFactory.setValidationQuery("select 1");
            
            GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
            
            poolConfig.setTimeBetweenEvictionRunsMillis(1000L, 60L, 5L);
            poolConfig.setTestWhileIdle(true);
            poolConfig.setMinIdle(4);
            poolConfig.setMaxTotal(50);
            
            GenericObjectPool<PoolableConnection> connectionPool =
                new GenericObjectPool<>(poolableConnFactory, poolConfig);
            
            poolableConnFactory.setPool(connectionPool);
            
            Class.forName("org.apache.commons.dbcp2.PoolingDriver");
            PoolingDriver driver = 
                (PoolingDriver)DeriverManager.getDriver("jdbc:apache:commons:dbcp:");
            
            String poolName = getInitParameter("poolName");  //poolName 초기화 파라미터
            
            driver.registerPool(poolName, connectionPool);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

chap17/WEB-INF/web.xml : DBCPInit2 를 위한 설정

<servlet>
    <servlet-name>DBCPInit2</servlet>
    <servlet-class>jdbc.DBCPInit2</servlet-class>
    <init-param>
        <param-name>jdbcdriver</param-name>
        <param-value>com.mysql.jdbc.Driver</param-value>
    </init-param>
    <init-param>
        <param-name>jdbcUrl</param-name>
        <param-value>
            jdbc:mysql://localhost:3306/chap14?characterEncoding=utf8
        </param-value>
    </init-param>
    <init-param>
        <param-name>dbUser</param-name>
        <param-value>root</param-value>
    </init-param>
    <init-param>
        <param-name>dbPass</param-name>
        <param-value>rootpw</param-value>
    </init-param>
    <init-param>
        <param-name>poolName</param-name>
        <param-value>chap14</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

JDBC URL 이나 다른 설정을 바꾸려면, 서블릿 코드를 변경할 필요 없이

web.xml 파일의 초기화 파라미터 값을 변경하면 된다.

getInitParameter() 메소드는 지정한 초기화 파라미터가 존재하면 해당 값을 리턴하고,

존재하지 않으면 null 을 리턴한다.

따라서 null 인 경우 기본값을 사용하고 싶거나, 다른 예외 처리를 하고 싶다면,

초기화 파라미터 값이 null 인지 여부를 확인한 후 알맞게 처리한다.

// 초기화 파라미터가 없으면 null 을 리턴한다.

String poolName = getInitParameter("poolName");

if (poolName == null) poolName = "pool";  // null 이라면 기본값 pool 사용

* 웹 어플리케이션에서 전반적으로 필요한 초기화 작업을 수행하는 다른 방법으로

ServletContextListener 를 사용하는 방법도 있다.

@WebServlet 어노테이션으로 매핑한 경우, 초기화 파라미터를 전달하려면,

initParams 속성의 값으로 @WebInitParam 어노테이션 목록을 전달한다.

@WebServlet(urlPatterns = {"/hello", "/hello1"},
    initParams = {
        @WebInitParam(name="greeting", value="Hello"),
        @WebInitParam(name="title", value="제목")
    }
}

* 초기화 파라미터를 사용하는 이유!

- 클래스의 수정 없이 초기화 과정에서 필요한 값을 수정할 수 있다.

- 단, WebInitParam 어노테이션을 이용해서 초기화 파라미터를 설정하면,

초기화 설정을 변경할 때 마다 자바 코드를 수정해야 하기 때문에 변경의 유연성이 떨어진다.

JSP - 서블릿 1. 기초

kephi — Sun, 1 Nov 2020 21:40:11 +0900

1. 서블릿 개발 과정

1. 서블릿 규약에 따라 자바 코드를 작성 한다.

2. 자바 코드 소스를 컴파일해서 클래스 파일을 생성

3. 클래스 파일을 /WEB-INF/classes 폴더에 패키지에 맞게 위치시킨다.

4. web.xml 파일에 서블릿 클래스를 설정한다. (url 매핑)

5. 톰캣 등의 웹 컨테이너 실행

6. 웹 브라우저에서 결과 확인

ex) chap17/src/example/NowServlet.java

package example;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class NowServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request,
    HttpServletResponse response) throws ServletException, IOException {
    	
        response.setContentType("text/html; charset=utf-8");
        
        PrintWriter out = response.getWriter();
        out.println("<html>");
        out.println("<head><title>현재 시간</title></head>");
        out.println("<body>");
        out.println("현재 시간은");
        out.print(new Date());
        out.println("입니다.");
        out.println("</body></html>");
    }
}

2. 서블릿 클래스 작성 과정

① 서블릿 클래스를 구현하려면 먼저 HttpServlet 클래스를 상속 받은 클래로 작성한다.

② 상속 받았다면, HTTP 방식 (get, post) 에 따라 알맞은 매소드를 재정의(Override) 해서 구현한다.

만약 GET 방식의 요청을 처리해야 한다면, doGet() 메소드를 재정의하여 처리한다.

doGet() 메소드는 HttpServletRequest, HttpServletResponse 두 파라미터를 가지고, 이 두 파라미터는 각각

JSP의 request 기본 객체와 response 기본 객체에 해당된다.

재정의한 메소드는 request 를 이용해서 웹 브라우저의 요청 정보를 읽어오거나,

response 를 이용해서 응답을 전송할 수 있다.

③ 응답을 전송하려면 먼저 response.setContentType() 메소드를 이용해서 응답 컨텐츠의 타입을 지정한다.

response.setContentType("text/html; charset=utf-8");

컨텐츠 타입이 text/html 이고 캐릭터셋이 utf-8 으로 지정한다.

(JSP 에서 page 디렉티브의 contentType 속성값과 동일하다.)

④ 응답 결과를 웹 브라우저로 전송한다.

response.getWriter() 로 문자열 데이터를 출력할 수 있는 PrintWriter 를 구해야 한다.

PrintWriter out = response.getWriter();

out.println("<html>");

...

PrintWriter 는 println() 메소드를 제공, 메소드를 사용해서 전송할 응답 데이터를 전달한다.

전달한 데이터는 웹 브라우저에 전송되어 화면에 출력된다.

* 서블릿 자바 코드 직접 컴파일 하기

이클립스가 아닌 직접 톰캣 폴더에 직접 자바 소스를 생성한다면, 서블릿 클래스 컴파일 시

서블릿 API를 클래스 패스에 추가해야 한다.

(서블릿 관련 jar 파일은 [톰캣설치경로]\lib\servlet-api.jar)

ex) chap17\WEB-INF\src\example\NowServlet.java 로 작성 했을 시,

- 해당 WEB-INF 폴더로 이동한다.

c:\>cd [톰캣설치경로]\webapps\chap17\WEB-INF

- classes 디렉토리를 생성한다.

c:\..>mkdir classes

- 클래스패스를 지정한다.

c:\..>set CLASSPATH=c:\[톰캣설치경로]]\lib\servlet-api.jar

c:\..>set CLASSPATH=classes; %CLASSPATH%

- 컴파일을 수행한다.

c:\..>javac -d classes src\example\NowServlet.java

컴파일에 성공하면 WEB-INF\classes\example 폴더에 NowServlet.class 파일이 생성된다.

3. web.xml로 매핑하기

ex) NowServlet 클래스를 web.xml 파일에 등록하기

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
        http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    version="3.1">
    
    <servlet>
        <servlet-name>now</servlet-name>
        <servlet-class>example.NowServlet</servlet-class>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>now</servlet-name>
        <url-pattern>/now</url-pattern>
    </servlet-mapping>
</web-app>

서블릿을 web.xml 에 등록하려면 두 가지를 설정해야 한다.

- 서블릿으로 사용할 클래스

- 서블릿과 URL 간의 매핑

<servlet> 태그를 사용해서 서블릿 클래스를 등록한다.

<servlet-name> 태그 : 해당 서블릿을 참조할 때 사용할 이름을 지정한다.

<servlet-class> 태그 : 서블릿으로 사용할 클래스의 완전한 이름(패키지 포함) 을 지정한다.

<servlet-mapping> 태그를 사용해서 매핑 정보를 등록한다.

<servlet-name> 태그 : 매핑할 서블릿의 이름을 지정한다.

<url-pattern> 태그 : 매핑할 URL 패턴을 지정한다.

따라서 URL 패턴으로 지정한 /now URL 을 입력하면, NowServlet 서블릿 클래스가 처리하게 된다.

http://localhost:8080/chap17/now

<url-pattern> 은 아래와 같이 한 번 이상을 사용할 수 있다.

각각의 URL 패턴에 해당 서블릿을 매핑할 수 있다.

<servlet-mapping>
    <servlet-name>now</servlet-name>
    <url-pattern>/now</url-pattern>
    <url-pattern>/now2</url-pattern>
</servlet-mapping>

/now, /now2 는 now 서블릿을 매핑하게 된다.

서블릿을 매핑할 때 사용하는 <url-pattern> 태그에 적용되는 주소는

웹 어플리케이션 경로(톰캣 경로 : webapps/chap17)를 제외한 나머지 경로를 기준으로 적용된다.

/now 가 실제 매핑되는 경로는 /chap17/now 가 된다.

4. 어노테이션으로 매핑하기

서블릿 3.0 버전부터는 @WebServlet 어노테이션을 사용하면,

web.xml 파일에 따로 등록하지 않아도 서블릿으로 등록된다. (톰캣 7 이상 버전)

웹 컨테이너는 @WebServlet 어노테이션이 적용된 클래스를 검색해서 서블릿으로 자동으로 등록한다.

ex) chap17/src/example/HelloServlet.java

package example;

import java.io.IOException;
import java.io.PrintWriter;

import.javax.servlet.ServletException;
import.javax.servlet.annotation.WebServlet;
import.javax.servlet.http.HttpServlet;
import.javax.servlet.http.HttpServletRequest;
import.javax.servlet.http.HttpServletResponse;

@WebServlet(urlPatterns = "/hello")
public class HelloServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    
        request.setCharacterEncoding("utf-8");
        response.setContentType("text/html; charset=utf-8");
        
        PrintWriter out = response.getWriter();
        out.println("<html>");
        out.println("<head><title>인사</title></head>");
        out.println("<body>");
        out.println("안녕하세요, ");
        out.println(request.getParameter("name"));
        out.println("님");
        out.println("</body></html>");        
    }
}

@WebServlet(urlPatterns = "/hello")

/hello 경로로 들어오는 URL 을 HelloServlet이 처리하도록 설정한다.

- HelloServlet 클래스를 컴파일한 뒤 톰캣을 재시작한다.

이후 http://localhost:8080/chap17/hello URL 로 HelloServlet 을 실행할 수 있게 된다.

- 만약 두 개 이상의 URL 패턴을 처리하도록 하고 싶다면 아래와 같이 urlPatterns 속성값으로

배열을 전달하면 된다.

@WebServlet(urlPatterns = {"/hello", "/hello1"} )

- @WebServlet 어노테이션 사용 시 고려할 점

서블릿이 범용적으로 사용되는 서블릿인지의 여부

예) MVC 프레임 워크는 어떤 URL을 서블릿이 처리할 지 미리 알 수 없다.

단지 다양한 요청 URL을 MVC 프레임 워크가 처리할 수 있는 기능을 구현할 수 있을 뿐이다.

따라서 @WebServlet 어노테이션을 사용할 경우, 서블릿이 처리해야 할 URL 패턴이 변경될 때마다,

소스 코드의 urlPatterns 속성 값을 변경하고 다시 컴파일 해야하는 불편함이 생긴다!!

web.xml 을 사용할 경우, URL 경로가 변경될 경우, web.xml 파일만 변경하면 되지만

@WebServlet 을 사용할 경우, 컴파일을 다시해야 한다.

따라서 서블릿의 용도에 따라 @WebServlet, web.xml 을 사용할 지를 알맞게 결정해야 한다.

* @WebServlet 어노테이션이 적용된 서블릿을 web.xml 파일에 등록한다면?? (두 개 동시!!)

이 경우에는 @WebServlet 어노테이션에 적용된 urlPatterns 의 URL 패턴과

web.xml 파일에 등록된 URL 패턴에 모두 매핑된다.

@WebServlet 어노테이션이 적용된 클래스의 객체가 생성되고,

web.xml 파일에서 지정된 클래스의 객체가 생성된다.

따라서 서로 다른 두 개의 객체가 생성되고 각각 @WebServlet 어노테이션에서 지정한

URL 패턴과, web.xml 에 지정한 URL 패턴에 매핑된다.

5. HTTP 각 전송방식 별 구현 메소드

HTTP 는 GET, POST, HEAD, PUT, DELETE 방식을 지원한다.

일반적으로 웹과 브라우저에서 사용되는 방식은 GET, POST 방식이다.

HttpServlet 클래스는 HTTP 방식에 따라 알맞은 메소드를 이용해서 구현하도록 정의하고 있다.

예) doGet() 메소드는 GET 방식을 처리, doPost() 메소드는 POST 방식을 처리하고 있다.

만약 GET, POST 방식을 모두 처리해야하는 경우, 두 메소드를 재정의(Override) 해서 처리한다.

GET 방식

@Override

protected void doGet(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException {

... // GET 방식에 대한 처리, 예) 폼 출력하기

}

POST 방식

@Override

protected void doPost(HttpServletRequest req, HttpServletResponse resp)

throws ServletException, IOException {

... // POST 방식에 대한 처리, 예) 폼 데이터 처리하기

}

16. Java 자바 [API] - java.time 패키지

kephi — Thu, 8 Oct 2020 09:28:44 +0900

자바 8 부터 추가된 날짜와 시간을 조작하는 여러 가지 추가된 API

패키지	설명
java.time	날짜와 시간을 나타내는 핵심 API 클래스를 포함 이 클래스들은 ISO-8601에 정의된 달력 시스템에 기초한다.
java.time.chrono	ISO-8601 에 정의된 달력 시스템 이외의 달력 시스템이 필요 시 사용하는 API
java.time.format	날짜와 시간을 파싱하고 포맷팅 하는 API
java.time.temporal	날짜와 시간을 연산하기 위한 보조 API
java.time.zone	타임존을 지원하는 API

java.time 패키지에는 아래와 같이 날짜와 시간을 표현하는 5개의 클래스가 있다.

- LocalDate : 로컬 날짜 클래스

- LocalTime : 로컬 시간 클래스

- LocalDateTime : 로컬 날짜 및 시간 클래스 (LocalDate + LocalTime)

- ZonedDateTime : 특정 타임존(TimeZone)의 날짜와 시간 클래스

- Instant : 특정 시점의 Time-Stamp 클래스

1. LocalDate

날짜 정보만 저장할 수 있다. LocalDate 객체는 두 가지 정적 메소드를 얻을 수 있다.

now() 메소드는 컴퓨터의 현재 날짜 정보를 저장한 LocalDate 객체를 리턴한다.

of() 메소드는 매개값으로 주어진 날짜 정보를 저장한 LocalDate 객체를 리턴한다.

LocalDate currDate = LocalDate.now();

LocalDate targetDate = LocalDate.of(int year, int month, int datOfMonth);

2. LocalTime

시간 정보만 저장할 수 있다. LocalTime 객체도 두 가지 정적 메소드를 얻을 수 있다.

now() : 컴퓨터의 현재 시간 정보를 저장한 LocalTime 객체를 리턴한다.

of() : 매개값으로 주어진 시간 정보를 저장한 LocalTime 객체를 리턴한다.

LocalTime currTime = LocalTime.now();

LocalTime targetTime = LocalTime.of(int hour, int minute, int second, int nanoOfSecond);

3. LocalDateTime

LocalDate + LocalTime 클래스로 날짜와 시간 정보를 모두 저장할 수 있다.

now() : 컴퓨터의 현재 날짜와 시간 정보를 저장한 LocalDateTime 객체를 리턴한다.

of() : 매개값으로 주어진 날짜와 시간 정보를 저장한 LocalDateTime 객체를 리턴한다.

LocalDateTime currDateTime = LocalDateTime.now();

LocalDateTime targetTime = LocalDateTime.of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond);

4. ZonedDateTime

달력 시스템의 타임존의 날짜와 시간을 저장하는 클래스

저장 형태 : 2014-04-21T07:50:24.017+09:00[Asia/Seoul] 맨 뒤에 타임존 정보가 붙는다.

now() : ZoneId 를 매개값을 주어 ZonedDateTime 객체를 리턴한다.

of() : 매개값은 java.util.TimeZone 의 getAvailableIDs() 메소드가 리턴하는 유효한 값중 하나를 넣어서

ZoneId 를 얻을 수 있다.

ZonedDateTime utcDateTime = ZonedDateTime.now(ZoneId.of(“UTC”));

ZonedDateTime londonDateTime = ZonedDateTime.now(ZoneId.of(“Europe/London”));

ZonedDateTime seoulDateTime = zonedDateTime.now(ZoneId.of(“Asia/Seoul”));

5. Instant

날짜, 시간 정보를 얻거나 조작하는데 사용하지 않고,

특정 시점의 타임스탬프로 사용된다. 주로 특정한 두 시점 간의 시간적 우선순위를 따질 때 사용한다.

java.util.Date 와 가장 유사한 클래스이지만, 차이점은 Date 는 로컬 컴퓨터의 현재 날짜와 시간 정보를 기준으로 하지만, Instant 는 협정세계시(UTC)를 기준으로 한다.

Instant instant1 = Instant.now();

Instant instant2 = Instant.now();

if(instant1.isBefore(instant2)) { System.out.println(“instant1이 빠릅니다.”); }

else if(instant1.isAfter(instant2)) { System.out.println(“instant1이 늦습니다.”); }

else { System.out.println(“동일한 시간입니다.”); }

System.out.println(“차이(nanos) : ” + instant1.until(instant2, ChronoUnit.NANOS));

isBefore(), isAfter() 는 시간 앞뒤 여부를 확인하는 메소드이다.

util() 메소드는 두 시점 간의 차이를 리턴한다.

1. 날짜와 시간에 대한 정보 얻기

LocalDate 와 LocalTime은 프로그램에서 날짜와 시간 정보를 이용할 수 있도록 아래와 같은 메소드를 제공한다.

클래스	리턴 타입	메소드(매개 변수)	설명
LocalDate	int	getYear()	년
	Month	getMonth()	Month 열거값
	int	getMonthValue()	월
	int	getDayOfYear()	일년의 몇 번째 일
	int	getDayOfMonth()	월의 몇 번째 일
	DayOfWeek	getDayOfWeek()	요일
	boolean	isLeapYear()	윤년 여부
LocalTime	int	getHour()	시간
	int	getMinute()	분
	int	getSecond()	초
	int	getNano()	나노초 리턴

LocalDateTime, ZonedDateTime은 날짜와 시간 정보를 모두 가지고 있기 때문에

위 표의 대부분의 메소드를 가지고 있다.

단, isLeapYear() LocalDate에만 있기 때문에 toLocalDate() 메소드로 LocalDate 변환한 후에 사용할 수 있다.

ZonedDateTime은 시간존에 대한 정보를 제공하는 아래 메소드를 추가로 가지고 있다.

클래스	리턴 타입	메소드(매개 변수)	설명
ZonedDateTime	ZoneId	getZone()	존아이디 리턴(Asia/Seoul)
ZonedDateTime	ZoneOffset	getOffset()	존 오프셋(시차) 리턴

2. 날짜와 시간 조작하기

날짜와 시간 클래스들은 날짜와 시간을 조작하는 메소드와 상대 날짜를 리턴하는 메소드들을 가지고 있다.

- 날짜와 시간 빼거나 더하기

클래스	리턴 타입	메소드(매개 변수)	설명
LocalDate LocalDateTime ZonedDateTime	LocalDate LocalDateTime ZonedDateTime	minusYear(long)	년 빼기
		minusMonths(long)	달 빼기
		minusDays(long)	일 빼기
		minusWeeks(long)	주 빼기
		plusYears(long)	년 더하기
		plusMonths(long)	달 더하기
		plusWeeks(long)	주 더하기
		plusDays(long)	일 더하기
		minusHours(long)	시간 빼기
		minusMinutes(long)	분 빼기
		minusSeconds(long)	초 빼기
		minusNanos(long)	나노초 빼기
		plusHours(long)	시간 더하기
		plusMinutes(long)	분 더하기
		plusSeconds(long)	초 더하기
		plusNanos(long)	나노초 더하기

각 메소드들은 수정된 LocalDate, LocalTime, LocalDateTime, ZonedDateTime 을 리턴하기 때문에

(.) 도트 연산자로 연결해서 순차적으로 호출할 수 있다.

예) LocalDateTime targetDateTime = now.PlusYear(1).minusMonths(2). ...

- 날짜와 시간 변경하기

클래스	리턴 타입	매소드(매개 변수)	설명
LocalDate LocalDateTime ZonedDateTime	LocalDate LocalDateTime ZonedDateTime	withYear(int)	년 변경
		withMonth(int)	월 변경
		withDatOfMonth(int)	월의 일 변경
		withDayOfYear(int)	년의 일 변경
		with(TemporalAdjust adjuster)	상대 변경
		withHour(int)	시간 변경
		withMinute(int)	분 변경
		withSecond(int)	초 변경
		withNano(int)	나노초 변경

with() 메소드는 상대 변경 : 현재 날짜를 기준으로 해의 첫 번째 일 또는 마지막 일, 달의 첫 번째 일 또는 마지막일, 달의 첫 번째 요일, 지난 요일 및 돌아오는 요일 등.. 상대적인 날짜를 리턴한다.

매개값은 TemporalAdjuster 타입으로 다음 표에 있는 TemporalAdjusters 정적 메소드를 호출하면 얻을 수 있다.

리턴 타입	메소드(매개 변수)	설명
TemporalAdjuster	firstDayOfYear()	이번 해의 첫 번째 일
	lastDayOfYear()	이번 해의 마지막 일
	firstDayOfNextYear()	다음 해의 첫 번째 일
	firstDayOfMonth()	이번 달의 첫 번째 일
	lastDayOfMonth()	이번 달의 마지막 일
	firstDayOfNextMonth()	다음 달의 첫 번째 일
	firstInMonth(DayOfWeek dayOfWeek)	이번 달의 첫 번째 요일
	lastInMonth(DayOfWeek dayOfWeek)	이번 달의 마지막 요일
	next(DayOfWeek dayOfWeek)	돌아오는 요일
	nextOrSame(DayOfWeek dayOfWeek)	돌아오는 요일(오늘 포함)
	previous(DayOfWeek dayOfWeek)	지난 요일
	previousOrSame(DayOfWeek dayOfWeek)	지난 요일(오늘 포함)

3. 날짜와 시간 비교하기

클래스	리턴 타입	메소드(매개 변수)	설명
LocalDate LocalDateTime	boolean	isAfter(ChronoLocalDate other)	이후 날짜인지 비교
		isBefore(ChronoLocalDate other)	이전 날짜인지 비교
		isEqual(ChronoLocalDate other)	동일 날짜인지 비교
LocalTime LocalDateTime	boolean	isAfter(LocalTime other)	이후 시간인지 비교
LocalTime LocalDateTime	boolean	isBefore(LocalTime other)	이전 시간인지 비교
LocalDate	Period	until(ChronoLocalDate endDateExclusive)	날짜 차이
LocalDate LocalTime LocalDateTime	long	until( Temporal endExclusive, TemporalUnit unit )	시간 차이
Period	Period	between( LocalDate startDateInclusive, LocalDate endDateExclusive )	날짜 차이
Duration	Duration	between( LocalDate startDateInclusive, LocalDate endDateExclusive )	시간 차이
ChronoUnit.YEARS	long	between( Temporal temporal1Inclusive, Temporal temporal2Exclusive )	전체 년 차이
ChronoUnit.MONTHS			전체 달 차이
ChronoUnit.WEEKS			전체 주 차이
ChronoUnit.DAYS			전체 일 차이
ChronoUnit.HOURS			전체 시간 차이
ChronoUnit.SECONDS			전체 초 차이
ChronoUnit.MILLIS			전체 밀리초 차이
ChronoUnit.NANOS			전체 나노초 차이

Period, Duration 은 날짜와 시간의 양을 나타내는 클래스이다.

Period는 년, 달, 일의 양을 나타내고, Duration은 시, 분, 초, 나노초의 양을 나타낸다.

(D-day, D-time 을 구할 때 사용된다.)

- Period, Duration에서 제공하는 메소드들

클래스	리턴 타입	메소드(매개 변수)	설명
Period	int	getYears()	년의 차이
		getMonths()	달의 차이
		getDays()	일의 차이
Duration	int	getSeconds()	초의 차이
Duration	int	getNano()	나노초의 차이

- between() 메소드

Period, Duration 의 between() 은 년, 달, 일, 초의 단순 차이를 리턴하고,

ChronoUnit 열거 타입의 between()은 전체 시간을 기준으로 차이를 리턴한다.

예) 2023년 1월 – 2024년 3월

Period, Duration 의 between() : 2

ChronoUnit.MONTHS.between() : 14

4. 파싱과 포맷팅

파싱 (parsing) : 문자열에서 날짜와 시간을 생성하는 메소드

포맷팅 (formatting) : 날짜와 시간을 문자열로 변환하는 메소드

- 파싱 메소드

날짜와 시간 정보가 포함된 문자열을 파싱해서 날짜와 시간을 생성하는 두 개의 parse() 정적 메소드

클래스

리턴 타입

메소드(매개 변수)

설명

LocalDate

LocalTime

LocalDateTime

ZonedDateTime

LocalDate

LocalTime

LocalDateTime

ZonedDateTime

parse(CharSequence)

ISO_LOCAL_DATE
포멧터를 사용

(“2024-03-07”)

parse(CharSequence, DateTimeFormatter)

다른 포멧터를 사용할 경우

ofPattern() 메소드로 정의

LocalDate localDate = LocalDate.parse(“2024-05-21”);

DateTimeFormatter formatter = DateTimeFormatter.ofPattern(“yyyy.MM.dd”);

LocalDate localDate = LocalDate.parse(“2024.05.21”, formatter);

DateTimeFormatter에는 표준화 된 포맷터들이 아래 상수로 미리 정의되어 있다.

ofPattern() 메소드를 사용하지 않고 바로 사용할 수 있다.

상수	설명	예
BASIC_ISO_DATE	Basic ISO date	“20111203”
ISO_LOCAL_DATE	ISO Local Date	“2011-12-03”
ISO_OFFSET_DATE	ISO Date with offset	“2011-12-03+01:00”
ISO_DATE	ISO Date with or without offset	“2011-12-03_01:00”; “2011-12-03”
ISO_LOCAL_TIME	Time without offset	“10:15:30”
ISO_OFFSET_TIME	Time with offset	“10:15:30+01:00”
ISO_TIME	Time with or without offset	“10:15:30+01:00”; “10:15:30”
ISO_LOCAL_DATE_TIME	ISO Local Date and Time	“2011-12-03T10:15:30”
ISO_OFFSET_DATE_TIME	Date Time with Offset	“2011-12-03T10:10:15:30+01:00”
ISO_ZONED_DATE_TIME	Zoned Date Time	“2011-12-03T10:15:30+01:00[Europe/Paris]”
ISO_DATE_TIME	Date and time with ZoneID	“2011-12-03T10:15:30+01:00[Europe/Paris]”
ISO_ORDINAL_DATE	Year and day of year	“2012-337”
ISO_WEEK_DATE	Year and Week	“2012-W48-6”
ISO_INSTANT	Date and Time of an Instant	“2011-12-03T10:15:30Z”
RFC_1123_DATE_TIME	RFC 1123 / RFC 822	“Tue, 3 Jun 2008 11:05:30 GMT

예를 들어 parse(CharSequence) 와 동일하게 “2024-05-21” 이라는 문자열을 파싱해서 localDate 객체를

얻으려면 아래코드를 사용한다.

LocalDate localDate = LocalDate.parse(“2024-05-21”, DateTimeFormatter.ISO_LOCAL_DATE);

만약 포멧터의 형식과 다른 문자열을 파싱하게 된다면 DateTimeParseException 예외가 발생한다.

- 포맷팅 메소드

클래스

리턴 타입

메소드(매개 변수)

LocalDate

LocalTime

LocalDateTime

ZonedDateTime

String

format(DateTimeFormatter formatter)

format() 매개값은 DateTimeFormatter 이고, 해당 형식대로 문자열을 리턴한다.

LocatDateTime now = LocalDateTime.now();

DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(“yyyy년 M월 a h시 m분”);

String nowString = now.format(dateTimeFormatter);

System.out.println(nowString); // 2020년 7월 31일 오전 9시 8분

15. Java 자바 [API] - Format 클래스

kephi — Tue, 29 Sep 2020 22:13:26 +0900

Format 클래스는 원하는 문자열로 조합하는 과정을 쉽게 해준다.

java.text 패키지에 포함되어 있고, 다양한 클래스들을 제공한다.

1. 숫자 형식 클래스 DecimalFormat

DecimalFormat 은 숫자 데이터를 원하는 형식으로 표현하기 위해 사용된다.

기호	의미	패턴 예시	1234567.89 변환 결과
0	10 진수(빈자리는 0으로 채움)	0 0.0 0000000000.00000	1234568 1234567.9 0001234567.89000
#	10 진수(빈자리는 채우지 않음)	# #.# ##########.#####	1234568 1234567.9 1234567.89
.	소수점	#.0	1234567.9
-	음수 기호	+#.0 -#.0	+1234567.9 -1234567.9
,	단위 구분	#,###,0	1,234,567,9
E	지수 문자	0.0E0	1.2E6
;	양수와 음수의 패턴을 모두 기술할 경우, 패턴 구분자	+#,### ; -#,###	+1,234,568(양수일 때) -1,234,568(음수일 때)
%	100을 곱한 후에 % 문자를 붙임	#.#%	123456789%
\u00A4	통화 기호	\u00A4 #,###	\ 1,234,568

적용할 패턴을 선택했다면, DecimalFormat 생성자 매개값으로 지정해서 객체를 생성하면 된다.

그리고 나서 format() 메소드를 호출해서 패턴이 적용된 문자열을 얻으면 된다.

DecimalFormat df = new DecimalFormat(“#,###.0”);

String result = df.format(1234567.89);

2. 날짜 형식 클래스 SimpleDateFormat

Date 클래스의 toString() 메소드는 영문으로 된 날짜를 리턴하는데, 만약 특정 문자열 포맷으로 얻으려면 java.text.SimpleDateFormat 클래스를 이용한다.

SimpleDateFormat의 패턴 작성에 사용되는 기호

패턴 문자	의미	패턴 문자	의미
y	년	H	시(0 ~ 23)
M	월	h	시(1 ~ 12)
d	일	K	시(0 ~ 11)
D	월 구분이 없는 일 (1 ~ 365)	k	시(1 ~ 24)
E	요일	m	분
a	오전 / 오후	s	초
w	년의 몇 번째 주	S	밀리세컨드 ( 1 / 1000 초)
W	월의 몇 번째 주

자릿수에 맞게 기호를 반복해서 작성할 수 있다. (yyyy년, MM, dd) 이 패턴을 SimepleDateFormat 의 생성자의 매개값으로 지정하새 객체를 생성하면 된다.

SimpleDateFormat sdf = new SimpleDateFormat(“yyyy년 MM월 dd일”);

String strDate = sdf.format(new Date());

System.out.println(strDate);

3. 문자열 형식 클래스 MessageFormat

데이터를 파일에 저장, 네트워크로 전송 시, 데이터베이스 SQL 문을 작성 시

일정한 형식의 문자열을 사용한다.

MessageFormat 클래스를 사용하면 문자열에 데이터가 들어갈 자리를 표시해 두고,

프로그램이 실행하면서 동적으로 데이터를 삽입하여 문자열을 완성 시킬 수 있다.

예) 회원 정보 출력

회원 ID : kephi

회원 이름 : 케피

회원 전화 : 010-1234-5678

만약 각각 정보가 id, name, tel 변수에 저장되어 있다면 아래와 같이 출력할 수 있다.

String result = “회원 ID : ”+ id + “\n회원 이름 : ” + name + “ \n회원 전화 : ” + tel;

MessageFormat 클래스 사용

String message = “회원 ID : {0} \n회원 이름 : {1} \n회원 전화 : {2}”;

String result = MessageFormat.format(message, id, name, tel);

MessageFormat은 정적 메소드 format() 을 호출해서 완성된 문자열을 리턴한다.

format의 첫 번째 매개 값은 매개 변수화된 문자열을 지정하고,

두 번째 이후의 매개 값은 인덱스 순서에 맞게 값을 나열한다. (배열을 대신 대입할 수도 있다.)

String text = “회원 ID : {0} \n회원 이름 : {1} \n회원 전화 : {2}”;

Object[] arguments = { id, name, tel };

String result = MessageFormat.format(text, arguments); // 배열로 전달!

System.out.println(result);

14. Java 자바 [API] - Date, Calendar 클래스

kephi — Tue, 29 Sep 2020 20:09:38 +0900

Date, Calendar 클래스는 java.util 패키지에 포함되어 있다.

1. Date 클래스

날짜를 표현하는 클래스로 객체 간에 날짜 정보를 주고 받을 때 주로 사용된다.

Date 클래스에는 여러 개의 생성자가 선언되어 있지만, 대부분 비권장(Deprecated) 되어

Date() 생성자만 주로 사용된다.

컴퓨터의 현재 날짜를 읽어 Date 객체로 만든다.

Date now = new Date();

현재 날짜를 문자열로 얻고 싶다면 toString() 메소드를 사용하면 된다.

영문으로 된 날짜를 리턴하고, 만약 특정 문자열 포멧으로 얻고 싶다면,

java.text.SimpleDateFormat 클래스를 이용한다.

예) DateExample.java : 현재 날짜 출력

public class DateExample {
    public static void main(String[] args) {
        Date now = new Date();
        String strNow1 = now.toString();
        System.out.println(strNow1);

        SimpleDateFormat sdf = new SimpleDateFormat(“yyyy년 MM월 dd시 mm분 ss초”);
        String strNow2 = sdf.format(now);
        System.out.println(strNow2);
    }
}

2. Calendar 클래스

달력을 표현한 클래스이다. 추상 클래스이므로 new 연산자를 사용해서 인스턴스를 생성할 수 없다.

(날짜, 시간 계산이 지역, 나라 마다 다르기 때문이다.)

Calendar 클래스의 정적 메소드 getInstance() 메소드를 이용하면,

현재 운영체제에 설정되어 있는 시간대(TimeZone)를 기준으로 한 Calendar 하위 객체를 얻을 수 있다.

Calendar now = Calendar getInstance();

Calendar 객체를 얻었다면 get 메소드를 통해 날짜와 시간에 대한 정보를 읽을 수 있다.

int year = now.get(Calendar.YEAR); // 년도 리턴

int month = now.get(Calendar.MONTH) + 1; // 월 리턴

int day = now.get(Calendar.DAY_OF_MONTH); // 일 리턴

int week = now.get(Calendar.DAY_OF_WEEK); // 요일 리턴

int ampm = now.get(Calendar.AM_PM); // 오전 / 오후 리턴

int hour = now.get(Calendar.HOUR); // 시간 리턴

int minute = now.get(Calendar.MINUTE); // 분 리턴

int second = now.get(Calendar.SECOND); // 초 리턴

다른 시간대로 바꾸는 방법은 Calendar 클래스의 오버로딩된 다른 getInstance() 메소드를 이용하면,

다른 시간대의 calendar 를 얻을 수 있다.

알고 싶은 시간대의 java.util.TimeZone 객체를 얻어서,

Calendar.getInstance() 메소드의 매개값으로 넘겨주면 된다.

TimeZone timeZone = TimeZone.getTimeZone(“America/Los_Angeles”);

Calendar now = Calendar.getInstance(timeZone);

예) PrintTimeZoneID.java : 사용 가능한 시간대 문자열 출력

public class PrintTimeZoneID {
    public static void main(String[] args) {
        String[] availableIDs = TimeZone.getAvailableIDs();
        for(String id : availableIDs) {
            System.out.println(id);
        }
    }
}

13. Java 자바 [API] - Math, Random 클래스

kephi — Tue, 29 Sep 2020 20:05:10 +0900

1. Math 클래스

java.lang.Math 클래스는 수학 계산에 사용할 수 있는 메소드를 제공한다.

해당 메소드들은 모두 정적(static) 이므로 Math 클래스로 바로 사용 가능하다.

메소드	설명	예제 코드	리턴값
int abs(int a) double abs(double a)	절대값	int v1 = Math.abs(-5); double v2 = Math.abs(-3.14);	v1 = 5 v2 = 3.14
double ceil(double a)	올림값	double v3 = Math.ceil(5.3); double v4 = Math.ceil(-5.3);	v3 = 6.0 v4 = -5.0
double floor(double a)	버림값	double v5 = Math.floor(5.3); double v6 = Math.floor(-5.3);	v5 = 5.0 v6 = -6.0
int max(int a, int b) double max(double a, double b)	최대값	int v7 = Math.max(5, 9); double v8 = Math.max(5.3, 2.5);	v7 = 9 v8 = 5.3
int min(int a, int b) double min(double a, double b)	최소값	int v9 = Math.min(5, 9); double v10 = Math.min(5.3, 2.5);	v9 = 5 v10 = 2.5
double random()	랜덤값	double v11 = Math.random();	0.0 <= v11 < 1.0
double rint(double a)	가까운 정수의 실수값	double v12 = Math.rint(5.3); double v13 = Math.rint(5.7);	v12 = 5.0 v13 = 6.0
long round(double a)	반올림값	long v14 = Math.round(5.3); long v15 = Math.round(5.7);	v14 = 5 v15 = 6

double value = 12.3456;

double temp1 = value * 100;

long temp2 = Math.round(temp1); // 소수 셋째 자리수에서 반올림!

double v16 = temp2 / 100.0;

System.out.println(“v16 = ” + v16);

round() 메소드는 항상 소수 첫 번째 자리에서 반올림해서 정수값을 리턴한다.

원하는 자리에서 반올림 하려면 반올림할 자리를 맞추기 위해 10ⁿ 을 곱한다.

random() 메소드는 0.0 과 1.0 사이의 범위에 속하는 하나의 double 타입 값을 리턴한다.

0.0 <= Math.random() < 1.0

1 ~ 10 까지의 정수 난수를 얻으려면 아래와 같은 순서로 연산식을 만든다.

① 각 변에 10을 곱하면 0.0 <= ... < 10.0 사이 하나의 double 타입의 값을 얻을 수 있다.

0.0 * 10 <= Math.random() < 1.0 * 10

② 각 변을 int 타입으로 강제 타입 변환하면 0 <= ... < 10 사이의 범위에 속하는

하나의 int 타입 값을 얻을 수 있다.

(int)(0.0 * 10) <= (int)(Math.random()*10) < (int)(1.0*10)

③ 각 변에 1을 더하면 1 <= ... < 11 사이의 범위가 된다.

(int)(0.0 * 10) + 1 <= (int)(Math.random()*10) < (int)(1.0*10) + 1

④ 따라서 start <= ... < start + n 범위에 속하는 하나의 정수를 얻기 위해서는 아래와 같은 연산식을 만들면 된다.

int num = (int) (Math.random() * n) + start;

예)

주사위 번호 뽑기 : int num = (int) (Math.random() * 6) + 1;

로또 번호 뽑기 : int num = (int) (Math.random() * 45) + 1;

2. Random 클래스

java.util.Random 클래스는 난수를 얻어내기 위한 다양한 메소드를 제공한다.

Math.random() 메소드는 0.0 ~ 1 사이의 double 난수를 얻는 데만 사용한다면,

Random 클래스는 boolean, int, long, float, double 난수를 얻을 수 있다.

Random 클래스는 종자값(seed)를 설정할 수 있다.

종자값은 난수를 만드는 알고리즘에 사용되는 값으로, 종자값이 같으면 같은 난수를 얻는다.

Random 클래스로 부터 Random 객체를 생성하는 생성자 2 가지

Random() : 호출 시마다 다른 종자값(현재 시간 이용) 이 자동 설정된다.

Random(long seed) : 매개값으로 주어진 종자값이 설정된다.

Random 클래스가 제공하는 메소드들

리턴값	메소드(매개 변수)	설명
boolean	nextBoolean()	boolean 타입의 난수를 리턴
double	nextDouble()	double 타입의 난수를 리턴 (0.0 <= ~ < 1.0)
int	nextInt()	int 타입의 난수를 리턴 (-2³¹ <= ~ <= (2³¹ - 1))
int	nextInt(int n)	int 타입의 난수를 리턴 (0 <= ~ < n)

예) RandomExample.java : 로또 번호 얻기

public class RandomExample {
    public static void main(String[] args) {
        //선택번호
        int[] selectNumber = new int[6];   // 선택 번호 6개가 저장될 배열 [자동]
        Random random = new Random(3);     // 선택 번호를 얻기 위한 Random 객체 생성
        System.out.print(“선택 번호 : ”);
        for(int i = 0; i < 6; i++) {
            selectNumber[i] = random.nextInt(45) + 1;  // 선택 번호를 얻어 배열에 저장
            System.out.print(selectNumber[i] + “ ” );
        }
        System.out.println();

        // 당첨번호
        int[] winningNumber = new int[6];   // 당첨 번호 6개가 저장될 배열
        random = new Random(5);              // 당첨 번호를 얻기 위한 Random 객체 생성
        System.out.print(“당첨 번호 : ”);
        for(int i = 0; i < 6; i++) {
            winningNumber[i] = random.nextInt(45) + 1;  // 당첨 번호를 얻어 배열에 저장
            System.out.println(winningNumber[i] + “ ” );
        }
        System.out.println();

        // 당첨 여부 확인하기
        Arrays.sort(selectNumber);    // 오름차순 정렬
        Arrays.sort(winningNumber);
        boolean result = Arrays.eqauls(selectNumber, winningNumber); // 배열 항목값 비교
        System.out.print(“당첨 여부 : ”);
        if(result) {
            System.out.println(“1등 당첨!!!”);
        } else {
            System.out.println(“꽝!”);
        }
    }
}