public int[] solution(String[] keyInput, int[] board) {
        return Arrays.stream(keyInput).map(s -> getMap().get(s)).reduce((ints1, ints2) -> new int[] {
                Math.abs(ints1[0] + ints2[0]) > board[0] / 2 ? board[0] / 2 * (ints1[0] < 0 ? -1 : 1) : ints1[0] + ints2[0],
                Math.abs(ints1[1] + ints2[1]) > board[1] / 2 ? board[1] / 2 * (ints1[1] < 0 ? -1 : 1) : ints1[1] + ints2[1]
        }).orElse(new int[]{0, 0});
    }

    private Map<String, int[]> getMap() {
        Map<String, int[]> map = new HashMap<>();

        map.put("up", new int[] {0, 1});
        map.put("down", new int[] {0, - 1});
        map.put("left", new int[] {-1, 0});
        map.put("right", new int[] {1, 0});
        return map;
    }

    public int solution(String[] spell, String[] dic) {
        return Arrays.stream(dic).
        map(s -> 
        s.chars().sorted().mapToObj(i -> String.valueOf((char) i)).collect(Collectors.joining())
        ).
        collect(Collectors.toList()).
        contains(
        Arrays.stream(spell).sorted().collect(Collectors.joining())
        ) ? 1 : 2;
    }

    public int solution(int i, int j, int k) {
        int count = 0;
        for (int t = i; t <= j; t++) {
            for (int p : Arrays.stream(String.valueOf(t).split("")).mapToInt(Integer::parseInt).toArray()) {
                if (p == k) {
                    count++;
                }
            }
        }
        return count;
    }

    public int solution(String my_string) {
        Matcher matcher = Pattern.compile("[-|+]\\s([0-9])+(,[0-9]+)?").matcher(my_string);
        Matcher firstNum = Pattern.compile("^[0-9]+(,[0-9]+)?").matcher(my_string);
        firstNum.find();
        int result = Integer.parseInt(firstNum.group().replace(",", "j"));
        while (matcher.find()) {
            String matchStr = matcher.group().replace(",", "");
            if (matchStr.contains("-")) {
                result -= Integer.parseInt(matchStr.replace("- ", ""));
            } else {
                result += Integer.parseInt(matchStr.replace("+ ", ""));
            }
        }
        return result;
    }

    public int solution(String myString) {
        return Arrays.stream(myString.replaceAll("- ", "-").replaceAll("[+] ", "").trim().split(" ")).mapToInt(Integer::parseInt).sum();
    }

    public String[] solution(String myStr, int n) {
        return IntStream.range(0, myStr.length() / n + (myStr.length() % n > 0 ? 1 : 0))
                .mapToObj(i -> i == myStr.length() / n ? myStr.substring(i * n) : myStr.substring(i * n, (i + 1) * n))
                .toArray(String[]::new);
    }

    public int solution(String myString) {
        return Arrays.stream(myString.split("[A-Z|a-z]")).filter(s -> !s.isEmpty()).mapToInt(Integer::parseInt).sum();
    }

    public String solution(String s) {
        return Arrays.stream(s.split(""))
                .collect(Collectors.groupingBy(s1 -> s1))
                .entrySet()
                .stream()
                .filter(entry -> entry.getValue().size() <= 1)
                .map(Map.Entry::getKey)
                .sorted()
                .collect(Collectors.joining());
    }

    public int solution(int i, int j, int k) {
        String str = "";
        for(int a = i; a <= j; a++) {
            str += a+"";
        }

        return str.length() - str.replace(k+"", "").length();
    }

    public int solution(int i, int j, int k) {
        return (int) Arrays.stream(IntStream.rangeClosed(i, j)
                        .mapToObj(String::valueOf)
                        .flatMap(String::lines)
                        .collect(Collectors.joining())
                        .split(""))
                .filter(s -> s.equals(String.valueOf(k)))
                .count();
    }

    public int solution(int num, int k) {
        return ("-" + num).indexOf(String.valueOf(k));
    }

    public String solution(String myString, int num1, int num2) {
        List<String> list = Arrays.stream(myString.split("")).collect(Collectors.toList());

        Collections.swap(list, num1, num2);
        return String.join("", list);
    }

    public int solution(int[] numbers) {
        int len = numbers.length;
        Arrays.sort(numbers);
        return Math.max(numbers[0] * numbers[1], numbers[len - 2] * numbers[len - 1]);
    }

class Solution {
    public String solution(String myString) {
        return myString.chars().mapToObj(operand -> String.valueOf((char) (Character.isLowerCase(operand) ? Character.toUpperCase(operand) : Character.toLowerCase(operand)))).collect(Collectors.joining());
    }
}

import java.util.stream.Collectors;
import java.util.stream.IntStream;

class Solution {
    public String solution(String cipher, int code) {
        return IntStream.range(0, cipher.length())
                .filter(value -> value % code == code - 1)
                .mapToObj(c -> String.valueOf(cipher.charAt(c)))
                .collect(Collectors.joining());
    }
}

    public int solution(int[] array, int n) {
        return Math.min(array[Arrays.stream(array).map(operand -> Math.abs(n - operand)).boxed().collect(Collectors.toList()).indexOf(Arrays.stream(array).map(operand -> Math.abs(n - operand)).min().orElse(0))], array[Arrays.stream(array).map(operand -> Math.abs(n - operand)).boxed().collect(Collectors.toList()).lastIndexOf(Arrays.stream(array).map(operand -> Math.abs(n - operand)).min().orElse(0))]);
    }

    public int solution(String[] babbling) {
        String regex = "(aya|ye|woo|ma)";
        int result = 0;
        for (String str :
                babbling) {
            if (str.replaceAll(regex, "").length() == 0) {
                result++;
            }
        }
        return result;
    }

    public int solution(String my_string) {
        int result = 0;
        Matcher matcher = Pattern.compile("[0-9]").matcher(my_string);
        while (matcher.find()) {
            result += Integer.valueOf(matcher.group());
        }
        return result;
    }

    public int solution(int n) {
        int answer = 0;
        return Math.sqrt(n) % 1 == 0 ? 1 : 2;
    }

    public String solution(String my_string) {
        String answer = "";

        answer = my_string.replaceAll("[aeiou]", "");

        return answer;

    public int solution(int n, int t) {
        int answer = 1;

        answer = n * (int)Math.pow(2, t);

        return answer;
    }

    public int solution(int n, int t) {
        int answer = 0;

        answer = n << t;

        return answer;
    }

    public int solution(int n) {
        return Arrays.stream(String.valueOf(n).split("")).mapToInt(Integer::parseInt).sum();
    }

class Solution {
    public int solution(String[] s1, String[] s2) {
        Set<String> set = new HashSet<>(Arrays.asList(s1));
        return (int)Arrays.stream(s2).filter(set::contains).count();
    }

    public int[] solution(int[] numbers, String direction) {
        List<Integer> list = Arrays.stream(numbers).boxed().collect(Collectors.toList());

        if (direction.equals("right")) {
            list.add(0, list.get(list.size() - 1));
            list.remove(list.size() - 1);
        } else {
            list.add(list.size(), list.get(0));
            list.remove(0);
        }
        return list.stream().mapToInt(Integer::intValue).toArray();
    }

    public int[][] solution(int[] num_list, int n) {
        return IntStream.range(0, num_list.length / n)
                .mapToObj(i -> IntStream.range(0, n)
                        .map(j -> num_list[i * n + j])
                        .toArray())
                .toArray(int[][]::new);
    }

    public int[][] solution(int[] num_list, int n) {
        int[][] answer = {};

        int length = num_list.length;

        answer = new int[length/n][n];

        for(int i=0; i<length; i++){
            answer[i/n][i%n]=num_list[i];
        }

        return answer;
    }

    Map<String, String> dictionary = new HashMap<>() {{
        put(".-", "a");
        put("-...", "b");
        put("-.-.", "c");
        put("-..", "d");
        put(".", "e");
        put("..-.", "f");
        put("--.", "g");
        put("....", "h");
        put("..", "i");
        put(".---", "j");
        put("-.-", "k");
        put(".-..", "l");
        put("--", "m");
        put("-.", "n");
        put("---", "o");
        put(".--.", "p");
        put("--.-", "q");
        put(".-.", "r");
        put("...", "s");
        put("-", "t");
        put("..-", "u");
        put("...-", "v");
        put(".--", "w");
        put("-..-", "x");
        put("-.--", "y");
        put("--..", "z");
    }};

    public String solution(String letter) {
        return Arrays.stream(letter.split(" "))
            .map(dictionary::get)
            .collect(Collectors.joining());
    }

    public int[] solution(int[] emergency) {
        int[] answer = new int[emergency.length];

        for(int i = 0; i < answer.length; i++){
            if(answer[i] != 0){
                continue;
            }
            int idx = 1;
            for(int j = 0; j < answer.length; j++){
                if(emergency[i] < emergency[j]){
                    idx++;
                }
            }
            answer[i] = idx;
        }
        return answer;
    }

    public int[] solution(int[] e) {
        return Arrays.stream(e).map(i -> Arrays.stream(e).boxed().sorted(Comparator.reverseOrder()).collect(Collectors.toList()).indexOf(i) + 1).toArray();
    }

    public String solution(int age) {
        return String.valueOf(age).chars().mapToObj(operand -> String.valueOf((char) (49 + operand))).collect(Collectors.joining());
    }

    public long solution(String numbers) {

            String[] numbers_arr = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};

            for (int i = 0; i < numbers_arr.length; i++) {
                numbers = numbers.replaceAll(numbers_arr[i], String.valueOf(i));
            }

            long answer = Long.parseLong(numbers);
            return answer;
        }

    public long solution(String numbers) {
        return Long.parseLong(
                numbers.replaceAll("zero", "0")
                        .replaceAll("one", "1")
                        .replaceAll("two", "2")
                        .replaceAll("three", "3")
                        .replaceAll("four", "4")
                        .replaceAll("five", "5")
                        .replaceAll("six", "6")
                        .replaceAll("seven", "7")
                        .replaceAll("eight", "8")
                        .replaceAll("nine", "9")
        );
    }

1. 짝수 홀수 개수

    public int[] solution(int[] num_list) {
        return Arrays.stream(num_list)
                .boxed()
                .collect(Collectors.partitioningBy(number -> number % 2 == 1, Collectors.counting()))
                .values().stream()
                .mapToInt(Long::intValue)
                .toArray();
    }

    public int[] solution(int[] numList) {
        return IntStream.of((int) Arrays.stream(numList).filter(i -> i % 2 == 0).count(), (int) Arrays.stream(numList).filter(i -> i % 2 == 1).count()).toArray();
    }

    public int[] solution(int[] num_list) {
        int[] answer = new int[2];

        for(int i = 0; i < num_list.length; i++)
            answer[num_list[i] % 2]++;

        return answer;
    }

        StringBuffer sb = new StringBuffer(str);
        String reverse = sb.reverse().toString();

1. 문자 반복 출력하기

    public String solution(String my_string, int n) {
        String answer = "";
        String[] str = my_string.split("");
        for(int i=0; i<my_string.length(); i++){
            answer += str[i].repeat(n);
        }
        return answer;
    }

    public String solution(String my_string, int n) {
        StringBuilder sb = new StringBuilder();
        for(char c : my_string.toCharArray()){
            sb.append((c + "").repeat(n));
        }
        return sb.toString();
    }

  Original data

**Religion** is a range of [social](https://en.wikipedia.org/wiki/Social_system "Social system")-[cultural systems](https://en.wikipedia.org/wiki/Cultural_system "Cultural system"), including designated [behaviors](https://en.wikipedia.org/wiki/Religious_behaviour "Religious behaviour") and practices, [morals](https://en.wikipedia.org/wiki/Morality "Morality"), [beliefs](https://en.wikipedia.org/wiki/Belief "Belief"), [worldviews](https://en.wikipedia.org/wiki/Worldview "Worldview"), [texts](https://en.wikipedia.org/wiki/Religious_text "Religious text"), [sanctified places](https://en.wikipedia.org/wiki/Sacred_site "Sacred site"), [prophecies](https://en.wikipedia.org/wiki/Prophecy "Prophecy"), [ethics](https://en.wikipedia.org/wiki/Ethics_in_religion "Ethics in religion"), or [organizations](https://en.wikipedia.org/wiki/Religious_organization "Religious organization"), that generally relate humanity to [supernatural](https://en.wikipedia.org/wiki/Supernatural "Supernatural"), [transcendental](https://en.wikipedia.org/wiki/Transcendence_(religion) "Transcendence (religion)"), and [spiritual](https://en.wikipedia.org/wiki/Spirituality "Spirituality") elements—although there is no scholarly consensus over what precisely constitutes a religion. Different religions may or may not contain various elements ranging from the [divine](https://en.wikipedia.org/wiki/Divinity "Divinity"), [sacredness](https://en.wikipedia.org/wiki/Sacredness "Sacredness"), [faith](https://en.wikipedia.org/wiki/Faith "Faith"), and a supernatural being or beings.

Pattern : [text](text "text")

Regex: \[.+?\]\(.+?\".+?\"\)

How to extract the following content from the original data using regular expressions

[cultural systems](https://en.wikipedia.org/wiki/Cultural_system "Cultural system")
[behaviors](https://en.wikipedia.org/wiki/Religious_behaviour "Religious behaviour")
[morals](https://en.wikipedia.org/wiki/Morality "Morality")
[beliefs](https://en.wikipedia.org/wiki/Belief "Belief")
[worldviews](https://en.wikipedia.org/wiki/Worldview "Worldview")
[texts](https://en.wikipedia.org/wiki/Religious_text "Religious text")
[sanctified places](https://en.wikipedia.org/wiki/Sacred_site "Sacred site")
[prophecies](https://en.wikipedia.org/wiki/Prophecy "Prophecy")
[ethics](https://en.wikipedia.org/wiki/Ethics_in_religion "Ethics in religion")
[organizations](https://en.wikipedia.org/wiki/Religious_organization "Religious organization")
[supernatural](https://en.wikipedia.org/wiki/Supernatural "Supernatural")
[transcendental](https://en.wikipedia.org/wiki/Transcendence_(religion) "Transcendence (religion)")
[spiritual](https://en.wikipedia.org/wiki/Spirituality "Spirituality")
[divine](https://en.wikipedia.org/wiki/Divinity "Divinity")
[sacredness](https://en.wikipedia.org/wiki/Sacredness "Sacredness")
[faith](https://en.wikipedia.org/wiki/Faith "Faith")

Pattern: [text](text "text")

Text that I want to find from the original content: 

Regex: grep -oP '(?<=\[)[^][]+(?=])' file

social
cultural systems
behaviors
morals
beliefs
worldviews
texts
sanctified places
prophecies
ethics
organizations
supernatural
transcendental
spiritual
divine
sacredness
faith

※stackoverflow: https://stackoverflow.com/questions/77810746/git-bash-regular-expression?noredirect=1#comment137175087_77810746

※Chat GPT

In a regular expression, [^][]+ is a character class that matches one or more characters that are not square brackets ([ and ]). Let's break down the components:

• [^]: This is a character class that matches any character except those listed within the brackets. The caret (^) at the beginning negates the character class, so it matches any character not specified. In this case, the character class [^] effectively means "any character except an empty set of characters," which is equivalent to "any character."
• []+: This part of the regular expression matches one or more characters that are listed within the square brackets. In this case, since the character class is [^], it means one or more characters that are not square brackets.

So, [^][]+ collectively means "match one or more characters that are not square brackets." This is often used when you want to capture or match text that is enclosed within certain delimiters, such as square brackets, and you want to exclude the delimiters themselves.

For example, in the regular expression (?<=\[)[^][]+(?=\]), the [^][]+ part is used to capture one or more characters between square brackets, excluding the brackets themselves.

20240103
ぶりっこ 귀여운 척
あざとかわいい
**装う**　よそう
あざとい
完売 かんばい
どんどん 점점
セールが始まったので、商品が次々に売り切れになっています。
在庫　ざいこ
入荷　にゅうか
転売　てんばい
ショッピング症候群　しょうこうぐん
通販　つうはん
福袋　ふくぶくろ
一〇九
気付かない
土地　とち
四角　しかく
クジラ
ぶつからない 부딪치지 않다
＊給仕う
優先　ゆうせん
怖がる　こわ
恐れる　おそ
むかつく
説明する気なくす

https://tailwindcss.com/

https://nerdcave.com/tailwind-cheat-sheet

<script src="https://cdn.tailwindcss.com"></script>

[폰트]

https://noonnu.cc/

https://fontawesome.com/

https://tailwindcomponents.com/components/buttons

mysql
https://www.phpschool.com/ 

https://www.phpschool.com/gnuboard4/bbs/board.php?bo_table=qna_db&wr_id=186770&sca=&sfl=wr_subject%7C%7Cwr_content&stx=db&sop=and 

https://tosuccess.tistory.com/123ww

[ tistory 단축키 ]

w : 작성

q : 관리자 페이지

a : 이전 글

s : 다음 글

https://goddaehee.tistory.com/134

[ 바탕화면 ] 

Shift + 검색 : 바탕화면에서 검색

Win + R - cmd

설정하기

Alt S - W - P - Colors and Fonts

--- Window - Preferences - Genearl - Appearance

-- Colors and Fonts

- part title font

- Tree and Table font for views

단축키

[ restore ]

- Window + R, cmd

- Alt ＋F11 : Toggle Full Screen

- Alt + Shift + Up / Down : 범위 확대/축소

- Ctrl + Shift + Up / Down : 동등 라인 이동

- Ctrl + Shift +Alt + L : Quick Search

- Ctrl + H : 찾기

- Ctrl + Shift + R : Search method

- Ctrl + Alt + G : Find Text in Workplace

- Alt + Shift + Q, S : Show View (Search)

- F3 : open Declaration

- Alt ＋Shift + Q, O : Show in (Outline)

Server

- Ctrl + Alt + R

[ Personal ]

Ctrl + Number_7 : Add Bookmark

Ctrl + Alt + Number_7

Alt + F11 : Toggle Full Screem

Ctrl + M

Ctrl + Shift + F6 키를 누르면 위로 커서가 움직인다.

Ctrl + F7 : 뷰간 전환

Ctrl + F6 : 편집기 이동

Ctrl + F8 : 퍼스펙티브간 전환

Ctrl + O : 메소드나 필드 이동하기

Ctrl + 1 : Quick Fix.

ALT + SHIFT + A : 블록 선택 모드

Alt + Shift + R : rename

Java Template

syst1 : System.out.println("${field} : " + ${field}); 

syst6 : System.out.println("${field} : " + ${field} +", ${index} : " + ${index}+", ${localVar} : " + ${localVar} + ", ${iterable} : " + ${iterable}+ ", ${iterable_element} : " + ${iterable_element}+ ", ${iterable_type} : " + ${iterable_type}  );
${cursor}

test1

System.out.println("test1");
${cursor}

https://sidebar.scrapbook.naver.com/feeds

//

https://github.com/AkimJemi/AllInOne_Akim

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

//

my_blog

https://github.com/AkimJemi/my_blog.git

dd

ss

JSP

<%@page import="java.util.ArrayList"%>
<%@page import="java.util.Iterator"%>
<%@page import="java.util.Enumeration"%>
<%@page import="java.util.Map"%>

//  첫번째  < Enumeration / ArrayList>
Enumeration a = (Enumeration) request.getParameterNames();
Enumeration<String> cd = a;
ArrayList cb3 = new ArrayList();
while (cd.hasMoreElements()) {
	System.out.println(cd.nextElement());
}

// 두번째  < Enumeration<String> >
Enumeration<String> cd2 = a;
while (cd2.hasMoreElements()) {
	cb3.add(cd2.nextElement());
}
for (int i = 0; i > cb3.size(); i++) {
	System.out.println(cb3.get(i));
}

String c = (String) request.getParameter("test3");
String d = (String) request.getParameter("test4");

 
 // 세번째  < String[] >
 String[] b = (String[]) request.getParameterValues("test1");
 System.out.println(b.length);
 for (int i = 0; i < b.length; i++) {
 	System.out.println(b[i]);
 }

 // 네번째  < Map >
 Map<String, String[]> map = (Map<String, String[]>) request.getParameterMap();
 System.out.println(map.size());
 System.out.println(map.entrySet());
 for (String key : map.keySet()) {
 	String[] value = map.get(key);
 	System.out.println("key : " + key + ", value : " + value[0]);
 }

<script type="text/javascript">
	function check_form() {
		var table_name = myform.table_name.value;
		if (table_name == '') {
			alert('테이블 명은 반드시 입력해야 합니다');
			myform.table_name.focus();
			return false;
		}
	}
</script>
</head>
<body>
	<h2>테이블 정보 출력</h2>
	<%
	if (request.getMethod().equalsIgnoreCase("get")) {
	%>
	<center>
		<form name="myform" method="post" onSubmit="return check_form()">
			<table width='300' border="0">
				<tr>
					<th width="100">테이블명</th>
					<td><input type="text" name="table_name" size='15' /></td>
				</tr>
				<tr>
					<th width="100">조건절</th>
					<td><input type="text" name="table_where" size='15' /></td>
				</tr>
				<tr>
					<td colspan='2' align='right'><input type="submit"
						value="테이블 정보 획득" /></td>
				</tr>
			</table>
		</form>
	</center>
	<%
	} else if (request.getMethod().equalsIgnoreCase("post")) {
	String table_name = request.getParameter("table_name");
	String table_where = request.getParameter("table_where");
	if (table_where == null)
		table_where = "";
	%>
	<center>
		<form name="myform" method="post" onSubmit="return check_form()">
			<table width='300' border="0">
				<tr>
					<th width="100">테이블명</th>
					<td><input type="text" name="table_name" size='15'
						value="<%=table_name%>" /></td>
				</tr>
				<tr>
					<th width="100">조건절</th>
					<td><input type="text" name="table_where" size='15' /></td>
				</tr>
				<tr>
					<td colspan='2' align='right'><input type="submit"
						value="테이블 정보 획득" value="<%=table_where%>" /></td>
				</tr>
			</table>
		</form>
	</center>
	<%
	String driver = config.getInitParameter("driver");
	String url = config.getInitParameter("url");
	String user_id = config.getInitParameter("user_id");
	String user_pw = config.getInitParameter("user_pw");
	Connection conn = null;
	try {
		Class.forName(driver);
		conn = DriverManager.getConnection(url, user_id, user_pw);
		String query = "select * from " + table_name;
		if (table_where != null && table_where.trim().length() != 0)
			query += " " + table_where;
		Statement stmt = conn.createStatement();
		ResultSet rs = stmt.executeQuery(query);
		ResultSetMetaData rsmd = rs.getMetaData();
	%>
	<table width='600' border='1'>
		<tr>
			<%
			for (int i = 1; i <= rsmd.getColumnCount(); ++i) {
				out.println("<td>" + rsmd.getCatalogName(i) + "</td>");
			}
			%>
		</tr>
		<%
		while (rs.next()) {
			out.println("<tr>");
			for (int i = 1; i <= rsmd.getColumnCount(); ++i) {
				if (rsmd.getColumnClassName(i).equalsIgnoreCase("Data"))
			out.println("<td>" + rs.getDate(i) + "</td>");
				else
			out.println("<td>" + rs.getString(i) + "</td>");
			}
		}
		%>
	</table>
	<%
	} catch (Exception ex) {
	out.println("Error : " + ex.getMessage() + "<br/><br/>");

	} finally {
	if (conn != null)
		conn.close();
	conn = null;
	}
	}
	%>
</body>

Web.xml

<servlet>
		<servlet-name>My_01</servlet-name>
		<jsp-file>/Round21_03_Page.jsp</jsp-file>
		<init-param>
		<param-name>driver</param-name>
		<param-value>org.gjt.mm.mysql.Driver</param-value>
		</init-param>
		<init-param>
		<param-name>url</param-name>
		<param-value>jdbc:mysql://localhost:3306/world</param-value>
		</init-param>
		<init-param>
		<param-name>user_id</param-name>
		<param-value>root</param-value>
		</init-param>
		<init-param>
		<param-name>user_pw</param-name>
		<param-value>1234</param-value>
		</init-param>
	</servlet>
	<servlet-mapping>
		<servlet-name>My_01</servlet-name>
		<url-pattern>/My_Page_01</url-pattern>
	</servlet-mapping>

Project

1-- Java Resources

2---- src

1-- bulid

1-- WebContent

2---- META-INF

2---- WEB-INF

3------ lib

2---- web.xml

[ web.xml ]

[ Handler ] 

[  ]

[  ]

[  ]

web.xml - Handler -

SingleTon Class

- ConnectionProvider

- ControllerUsingURI 

- 

- 

- 

Board 만둘기 과정

Connection 관련 코드 (583

[1] DBCPInitListener.class

[] web.xml / add <listener>, <context-param>

[] ConnectionProvider.class  / dbconnTest.jsp 만들어 테스트

[] web.xml / add < filter >, < filter-mapping > encodingFilter

[] util.CharacterEncodingFilter.class

MVC 컨트롤러 코드 (589

[] mvc.command.CommandHandker

[] mvc.command.NullHandler

[] mvc.controller.ControllerUsingURI

[] web.xml / add < servlet >, < servlet-mapping > ControllerUsingURI

[] commandHandlerURI.properties

기능 구현 (590

[] sql 작성

[] Member.class

[] MeberDao.class

[] JoinRequest

[] Join

[] 

[] 

[] 

[] 

[] 

[] 

[] 

[] web.xml / add <  >, <  > 

Handler - Service - Dao - DB

Handler  - .jsp

Service  - Request

Dao  - VO

web.xml

<filter>		
		<filter-name>LoginCheckFilter</filter-name>
		<filter-class>filter.LoginCheckFilter</filter-class>
		<init-param>
			<param-name>filterInitParam</param-name>
			<param-value>김재민</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>LoginCheckFilter</filter-name>
		<url-pattern>/changePwd.do</url-pattern>
		<url-pattern>/article/write.do</url-pattern>
		<url-pattern>/article/modify.do</url-pattern>
	</filter-mapping>

	<filter>
		<filter-name>encodingFilter</filter-name>
		<filter-class>util.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>

	<listener>
		<listener-class>jdbc.DBCPInitListener</listener-class>
	</listener>
    
	<context-param>
		<param-name>poolConfig</param-name>
		<param-value>
        jdbcdriver=com.mysql.jdbc.Driver
		jdbcUrl=jdbc:mysql://localhost:3306/board?characterEncoding=utf8
		dbUser=root
		dbPass=1234
		validationQuery=select 1
		minIdle=3
		maxTotal=30
		poolName=cosmoBoard
		</param-value><!-- poolName : ConnectionProvider에서 매치 -->
	</context-param>

    
	<servlet>
		<servlet-name>ControllerUsingURI</servlet-name>
		<servlet-class>mvc.controller.ControllerUsingURI</servlet-class>
		<init-param>
			<param-name>configFile</param-name>
			<param-value>/WEB-INF/commandHandlerURI.properties</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>ControllerUsingURI</servlet-name>
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>

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

\ 개발언어 : 자바

\ 웹/어플레케이션 서버 : HTTPD. 톰캣, 웹로직 등

\ 서버웹 기술 : JSP와 서블릿

\ 서버웹 기술을 위한 프레임워크 : 스프링 MVC

\ 클라이언트 웹 기술 : HTML, 자바 스크립트

\ 클라이언트 웹 기술을 위한 프레임워크나 라이브러리 : jQuery, 앵귤러 JS

\ 데이터베이스 연동 : JDBC, MS SQL, 오라클

\ DBMS : MySQL, MS SQL, 오라클

\ 통신 프로토콜 : HTTP

\ OS : 센트OS, 원도우 서버 2012 

- JSP를 이용한 웹 사이트 개발

- 서버 코드의 전형적인 구조(서비스-DAO, DTO 구성)

- 서블릿에 대한 기초

- MVC 구조에 대한 기초

- JSP와 DB를 연동한 게시판 개발

클래스 : 객체를 정의하는 틀 또는 설계도와 같은 의미

- 클래스는 객체의 상태를 나타내는 필드(field)와 객체의 행동을 나타내는 메소드(method)로 구성

필드 : 클래스에 포함된 변수(variable)를 의미

메서드 : 어떠한 특정 작업을 수행하기 위한 명령문의 집합

클래스의 인스턴스 화 :

자바에서 클래스를 사용하기 위해서는 우선 해당 클래스 타입의 객체(object)를 선언해야 합니다.

이렇게 클래스로부터 객체를 선언하는 과정

인스턴스란 메모리에 할당된 객체를 의미

API : 애플리케이션 소프트웨어를 빌드하고 통합하기 위한 정의 및 프로토콜 세트인 애플리케이션 프로그래밍 인터페이스(Application Programming Interface)

프로그램들이 서로 상호작용하는 것을 도와주는 매개체

API의 역할은? 

1. API는 서버와 데이터베이스에 대한 출입구 역할을 한다.

2. API는 애플리케이션과 기기가 원활하게 통신할 수 있도록 한다.

3. API는 모든 접속을 표준화한다.

new 키워드 : 객체를 생성하는 방법 중, 생성자 함수(Constructor) 를 사용하여 객체를 만들 때 함께 쓰는 키워드

📌 생성자 함수란?

생성자 함수를 통해 새로 만든 객체에 속할 변수들을 초기화 하는 역할

자바의 패키지 : 클래스와 인터페이스의 집합

자바 컬렉션 API : 

java.util.List 인터페이스 : java의 java.util 패키지에 속하는 인터페이스 객체를 담고 있는 순서가 있는 컬렉션

- 컬렉션 요소의 순서가 지정되어 있기 때문에 요소가 삽입되는 위치를 정확하게 제어할 수 있으며, 인덱스 번호로 요소 접근 및 검색이 가능

- Set(집합) 인터페이스와 달리 요소의 중복을 허용하고, null 값의 요소 추가도 가능하지만 일반적으로 추가하는 경우 예외를 발생

List 인터페이스 하위 클래스

• ArrayList
• LinkedList
• AbstractList
• AbstractSequentialList

Set 인터페이스 하위 클래스

• HashSet

Map 인터페이스 하위 클래스

• HashMap
• Properties [ Map 계열이지만 String 배열으로 저장된다. ]

java.util.ArrayList 클래스 : ArrayList 클래스는  Collection 프레임워크의 List인터페이스의 제너릭 클래스를 배열 형태로 관리할 수 있도록 하는 클래스로 순차적으로 자료를 저장하여 관리하는 프로그램을 구현할 때 사용되는 클래스

클래스 패치 : 클래스패스란 말 그대로 클래스를 찾기위한 경로이다.  즉, JVM이 프로그램을 실행할 때, 클래스파일을 찾는 데 기준이 되는 파일 경로를 말하는 것

특정 코드를 작성할 필요 없이 데이터를 선언적으로 처리하고 멀티코어 아키텍처를 활용할 수 있도록 하는

인터페이스 : 다른 클래스를 작성할 때 기본이 되는 틀을 제공하면서, 다른 클래스 사이의 중간 매개 역할까지 담당하는 일종의 추상 클래스를 의미

추상 클래스 : 추상 메소드 + 생성자, 필드, 일반 메소드도 포함

인터페이스(interface) : 오로지 추상 메소드와 상수만을 포함

// 

1. 다형성 (Polymorphism)

하나의 객체가 여러 가지 타입을 가질 수 있는 것을 의미합니다.

자바에서는 이러한 다형성을 부모 클래스 타입의 참조 변수로 자식 클래스 타입의 인스턴스를 참조할 수 있도록 하여 구현하고 있습니다.

• Java에서는 한 타입의 참조변수로 여러 타입의 객체를 참조할 수 있도록 하는 것.
• 부모클래스 타입의 참조변수로 자식클래스의 인스턴스를 참조할 수 있도록 하는 것.
• 참조변수의 타입이 참조변수가 참조하고 있는 인스턴스에서 사용할 수 있는 멤버의 개수를 결정한다.
• 모든 참조변수는 null 또는 4 byte의 주소값이 저장된다.

///

[ JVM ] 

Java Virtual Machine의 줄임말.

직역하면 '자바를 실행하기 위한 가상 기계(컴퓨터)'

1. 출력 버퍼

  -> 임시 저장소

       JSP 페이지는 생성된 결과를 곧바로 웹 브라우저에 전송하지 않고, 출력 버퍼라고 불리는 곳에 임시로 출력 결과를 저장했다가 한번에 웹 브라우저에 전송한다.

2. 출력 버퍼 사용 시 장점!!

  ① 데이터 전송 성능이 향상된다.

  ② 곧바로 웹 브라우저로 전송되지 않기 때문에, JSP 실행 도중에 버퍼를 비우고 새로운 내용을 보여줄 수 있다.

  ③ 버퍼가 다 차기 전까지는 헤더를 변경할 수 있다.

3. page 디렉티브에서 버퍼 설정하기 - buffer 속성과 autoFlush 속성

  ① 설정방법 - kb 단위로 버퍼의 크기 지정 

    <%@ page buffer = "4kb" %>

  ② 버퍼의 기본 크기 

     일반적으로 buffer의 크기는 지정하지 않는다. defalut 크기는 8kb이다 왜냐하면 웹 어플리케이션이 만들어 내는 출력 결과가 대부분 8kb 이내이고, 버퍼의 크기가 8kb일 때가 평균적으로 가장 높은 성능을 보이기 때문이다.

  ③ 버퍼를 사용하고 싶지 않을 때

  <%@ page buffer = "none" %>

      단점 : 곧바로 전송되기 때문에 출력한 내용을 취소할 수 없다.

               <jsp:foward> 기능 사용 못함.

               (하나의 jsp 페이지에서 다른 jsp 페이지로 요청 처리를 전달할 때 사용)

  ④ flush

   page 디렉티브는 autoFlush 속성을 제공하고 있는데, 이 속성을 사용하면 버퍼가 다 찼을 때 어떻게 처리할지를 결정할 수 있다. autoFlush 속성은 "true " or "false"를 값으로 갖는다.

     true - 버퍼가 다 찼을 경우 버퍼를 플러시하고 계속해서 작업을 진행한다.

     flase - 버퍼가 다 찻을 경우 예외를 발생시키고 작업을 중지한다.

쿠키(cookie) : 웹 브라우저가 보관하는 데이터

웹 브라우저는 웹 서버에 요청을 보낼 때 쿠키와 함께 전송한다. 

구성 : 이름, 값, 유효시간, 도메인, 경로

생성 :

Cookie cookie = new Cookie("cookieName", "cookieValue");

response.addCookie(cookie);

208

218

522

1. HTTP 요청받음

2. 클라이언트가 요구하는 기능을 분석

3. 요청한 비지니스로직을 처리하는 모델 사용

4. 결과를

5. 

- JSP

Command 객체

CommandHandler

FileReader ->FileInputStream

Iterator
컬렉션 프레임웍에서는 컬렉션에 저장된 요소들을 읽어오는 방법을 표준화한다.

Map - 순서 없다/ 중복 배제

Properties<keySet, value><String, String>

forName 인스턴스화의 한 과정 *new 연산자 

Class.forName

web.xml Filter 이름 지정 실패

java.util.concurrent.ExecutionException: org.apache.catalina.LifecycleException: 구성요소 [StandardEngine[Catalina].StandardHost[localhost].StandardContext[/JSPProject]]을(를) 시작하지 못했습니다.

<filter>
<filter-name>My_Ft_01</filter-name>
<filter-class>Round18_01_Filter</filter-class>
</filter>
<filter-mapping>
<filter-name>My_Ft_01</filter-name>
<url-pattern>/Servlet_01</url-pattern>
</filter-mapping>
<servlet>
<servlet-name>My-01</servlet-name>
<servlet-class>Round18_01_Servlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>My_01</servlet-name>
<url-pattern>/Servlet_01</url-pattern>
</servlet-mapping>

out.println("<img src='Servlet_05_Sub?agree=" + agree);
out.println("&disagree=" + disagree + "'/>");

JSP

commandHandlerURI.properties에 지정된 경로 다른 프로젝트에 있으면 충돌 classNotFound error

あえて (aete): dare to

ー

あくまでも (akumade mo): to the end, to the utmost degree

ー

案の定 (an no jou): just as one thought

ー

あらかじめ (arakajime): beforehand, in advance

ー

あっての (atte no): to owe everything to

ー

場合によっては (baai ni yotte wa): depending on the situation

ー

ばこそ (ba koso): only because

ー

ばそれまでだ (ba sore made da): if… then it’s over

ー

べからず (bekarazu): must not, should not

ー

べく (beku): in order to, should

ー

べくもない (beku mo nai): can’t

ー

びる (biru): seeming to be

ー

ぶり (buri): style, manner

ー

ぶる (buru): behaving like

ー

だに (dani): even

ー

だの～だの (dano~dano): and, and so forth

ー

であれ～であれ (de are~de are): whether A or B

ー

であれ/であろうと (de are/de arou to): whoever/whatever/however

ー

でも何でもない (demo nan demo nai): not in the least

ー

でなくてなんだろう (denakute nan darou): must be, is definitely

ー

ではあるまいか (dewa aru mai ka): I wonder if it’s not

ー

ではあるまいし (dewa aru mai shi): it’s not like, it isn’t as if

ー

ではすまない (dewa sumanai): it doesn’t end with just

ー

どうにも～ない (dou nimo~nai): not … by any means

ー

がてら (gatera): on the same occasion

ー

が早いか (ga hayai ka): as soon as

ー

が最後 (ga saigo): once something occurs, something else happens

ー

ごとき/ごとく (gotoki/gotoku): like, as if

ー

ぐるみ (gurumi): together with

ー

羽目になる (hame ni naru): to end up with (something unpleasant)

ー

ひとつ (hitotsu): to give something a try

ー

ほどのことはない (hodo no koto wa nai): not worth, no need to

ー

ほかに～ない (hoka ni~nai): no other

ー

ほうがましだ (hou ga mashi da): I would rather

ー

いかなる (ikanaru): any kind of

ー

いかんでは/いかんによっては (ikan dewa/ikan ni yotte wa): depending on

ー

いかんによらず (ikan ni yorazu): regardless of

ー

いかに (ikani): how

ー

いかにも (ikanimo): indeed, really

ー

いまだに (ima da ni): still, even now

ー

いずれにせよ (izure nise yo): at any rate, in any case

ー

じみた (jimita): to look like

ー

限りだ (kagiri da): I feel so

ー

かいもなく (kai mo naku): even though

ー

か否か (ka ina ka): whether or not

ー

可能性がある (kanousei ga aru): there’s a possibility

ー

からある (kara aru): as much as, as many as

ー

かれ～かれ (kare~kare): or

ー

かたがた (katagata): while, for the purpose of

ー

かたわら (katawara): while, at the same time

ー

かつて (katsute): once, before

ー

嫌いがある (kirai ga aru): to have a tendency to

ー

きっての (kitte no): the most … of all

ー

きりがない (kiri ga nai): there’s no end to

ー

極まる/極まりない (kiwamaru/kiwamarinai): extremely

ー

極めて (kiwamete): extremely, exceedingly

ー

ことだし (koto dashi): because, since

ー

ことごとく (koto gotoku): altogether, entirely

ー

ことなしに (koto nashi ni): without doing something

ー

ことのないよう (koto no nai you): so as not to

ー

こととて (kototote): because, since

ー

くらいなら (kurai nara): rather than

ー

くらいのものだ (kurai no mono da): only

ー

までだ (made da): only

ー

までもない (made mo nai): it’s not necessary to

ー

まじき (majiki): should not, must not

ー

ままに (mama ni): to do as

ー

まみれ (mamire): to be covered in

ー

まるっきり (marukkiri): totally, completely

ー

めく (meku): to show signs of

ー

もはや (mohaya): already, no longer

ー

も顧みず/を顧みず (mo kaerimizu/o kaerimizu): regardless of, despite

ー

もしないで (mo shinaide): without even doing

ー

もので (mono de): because, for that reason

ー

ものを (mono o): I wish, if only

ー

ものと思われる (mono to omowareru): to think, to suppose

ー

ものとして (mono toshite): to assume, to suppose

ー

もさることながら (mo saru koto nagara): not only… but also

ー

もしくは (moshikuwa): or, otherwise

ー

ながらに/ながらの (nagara ni/nagara no): while, during

ー

ないではおかない/ずにはおかない (nai dewa okanai/zu niwa okanai): will definitely, cannot not

ー

ないではすまない/ずにはすまない (nai dewa sumanai/zu niwa sumanai): must

ー

ないまでも (nai made mo): even if something isn’t done

ー

ないものか (nai mono ka): can’t we…?, can’t I…?

ー

ないものでもない (nai mono demo nai): (something) is not entirely impossible

ー

ないとも限らない (nai tomo kagiranai): might

ー

なくして (nakushite): without

ー

何しろ (nani shiro): in any case, as you know

ー

なしに (nashi ni): without

ー

ならでは (nara dewa): uniquely applying to

ー

ならいざしらず (nara iza shirazu): I don’t know about A, but B

ー

なり (nari): as soon as

ー

なり～なり (nari~nari): or

ー

なりに/なりの (nari ni/nari no): in one’s own way or style

ー

なりとも (naritomo): even a little, at least

ー

に値する (ni atai suru): to be worth, to deserve

ー

にあたらない (ni ataranai): it’s not worth, there’s no need to

ー

にあって (ni atte): at, during, in the condition of

ー

にひきかえ (ni hikikae): in contrast to

ー

に至るまで (ni itaru made): until, as far as

ー

に至っては (ni itatte wa): as for, when it comes to

ー

に言わせれば (ni iwasereba): if you ask, if one may say

ー

にかかっている (ni kakatte iru): to depend on

ー

にかたくない (ni katakunai): it’s not hard to

ー

にまつわる (ni matsuwaru): to be related to

ー

にもほどがある (nimo hodo ga aru): to have a limit, to go too far

ー

にもまして (ni momashite): more than, above

ー

に則って (ni nottotte): in accordance with

ー

に先駆けて (ni saki gakete): to be the first

ー

にしたって (ni shitatte): even, even if

ー

にして (ni shite): only, in (time span)

ー

に即して (ni sokushite): in keeping with

ー

にたえる/にたえない (ni taeru/ni taenai): can/can’t do something

ー

に足る/に足りる (ni taru/ni tariru): to be enough, to be worthy of

ー

に足りない (ni tarinai): to be not worth

ー

に照らして (ni terashite): in comparison with, according to

ー

にとどまらず (ni todomarazu): not limited to

ー

には及ばない (niwa oyobanai): there’s no need to

ー

によらず (ni yorazu): regardless of

ー

んばかりに (n bakari ni): as if, as though

ー

んがため (n ga tame): in order to

ー

の至り (no itari): utmost