반응형

JAVA에서 소켓통신을 위한 예제입니다.

단순 문자열처리, VO객체 정보를 직렬화하여 처리하기, JSON형태로 데이터 주고 받기 3가지 방식에 대해 알아볼 예정이며 이번 포스팅에서는 단순 메시지를 주고 받는 예제를 진행하겠습니다.

 

Socket Server

SocketThreadServer.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

import org.apache.log4j.Logger;

public class SocketThreadServer extends Thread {
	
	private static final Logger logger = Logger.getLogger(SocketThreadServer.class);
	
	private Socket socket;

	public SocketThreadServer(Socket socket){
		this.socket=socket;
	}
	
	//단순 문자열 Thread server
	public void run(){
		BufferedReader br = null;
		PrintWriter pw = null;
		try{
			String connIp = socket.getInetAddress().getHostAddress();
			System.out.println(connIp + "에서 연결 시도.");
			
			/*
			 * 접근한 소켓 계정의 ip를 체크한다. KTOA 연동 모듈인지 체크 
			 * 정상이면 먼저 정상 접근되었음을 알린다.
			 **/
			br = new BufferedReader(
			        new InputStreamReader(socket.getInputStream()));
			
			pw = new PrintWriter(socket.getOutputStream());
			
			// 클라이언트에서 보낸 문자열 출력
			System.out.println(br.readLine());
			
			// 클라이언트에 문자열 전송
			pw.println("수신되었다. 오버");
			pw.flush();		
		}catch(IOException e){
			logger.error(e);
		}finally{
			try{
				if(pw != null) { pw.close();}
				if(br != null) { br.close();}
				if(socket != null){socket.close();}
			}catch(IOException e){
				logger.error(e);
			}
		}
	}
}

 

App.java - main()

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import org.apache.log4j.Logger;

import com.psw.socket.SocketThreadServer;

public class App {
	
	private static final Logger logger = Logger.getLogger(App.class);
	
	private static final int PORT_NUMBER = 4432;
	
	public static void main(String[] args) throws IOException{
		
		logger.info(":::                                                :::");
		logger.info(":::       Socket Application  Process Start        :::");
		logger.info(":::                                                :::");
		
		try(ServerSocket server = new ServerSocket(PORT_NUMBER)){
			while(true){
				Socket connection = server.accept();
				Thread task = new SocketThreadServer(connection);
				task.start();
			}
		}catch(IOException e){
			logger.error(e);
		}
	}
}

 

 

Socket Client

Client1.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class Client1 {
	private Socket socket;
	private BufferedReader br;
	private PrintWriter pw;
	
	public Client1(String ip, int port) {
		try {
			// 서버에 요청 보내기
			socket = new Socket(ip, port);
			System.out.println(socket.getInetAddress().getHostAddress() + "에 연결됨");
			
			// 메시지 받기
			br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			pw = new PrintWriter(socket.getOutputStream());
			
			// 메세지 전달
			pw.println("메시지를 발송한다. 오버!");
			pw.flush();
			
			// 응답 출력
			System.out.println(br.readLine());
		} catch (IOException e) {
		    System.out.println(e.getMessage());
		} finally {
		    // 소켓 닫기 (연결 끊기)
		    try {
		    	if(socket != null) { socket.close(); }
		        if(br != null) { br.close(); }
		        if(pw != null) { pw.close(); }
		    } catch (IOException e) {
		        System.out.println(e.getMessage());
		    }
		}
	}
}

 

App.java

public class App{
    public static void main( String[] args ) {
    	String ip = "연결할 주소(ip)";
        int port = 4432;
        new Client1(ip, port);
    }
}

 

실행 결과

1. 서버를 먼저 실행합니다.

Socket Server start!

 

2. 소켓서버가 열리면 클라이언트에서 연결정보로 연결 후 메시지를 발송합니다.

클라이언트에서 서버에 연결
서버로 전달된 메시지

 

3. 서버에서는 클라이언트가 발송한 문자열을 출력하고 전달할 문자열을 발신합니다.

답신 도착

반응형
반응형

스프링 구조에서만 Mybatis를 사용해보고 Maven 프로젝트에서 Mybatis연결은 처음해보게 되었는데, 항상 Autowired와 같은 어노테이션과 설정으로 자동으로 DI(의존성주입)처리가 된 DAO를 사용하다가 이번에 싱글톤 형태로 구성하여 최초에만 연결처리를 하고 연결된 객체를 계속해서 사용할 수 있도록 구성해보았습니다.

 

Mybatis 설정하기

pom.xml

<!-- MyBatis -->
<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis</artifactId>
	<version>3.4.1</version>
</dependency>

<!-- Mysql -->
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.31</version>
</dependency>

Mysql에 연결하는 예제로 진행됩니다.

 

 

mybatis 연결정보를 담아놓을 xml을 만들겠습니다.

mybatis 패키지를 추가하시고 mybatis-config.xml을 생성합니다.

 

mybatis-config.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<settings>
		<setting name="cacheEnabled" value="false"/>
		<setting name="useGeneratedKeys" value="ture"/>
		<setting name="lazyLoadingEnabled" value="true"/> 
		<setting name="defaultExecutorType" value="BATCH"/>
		<setting name="defaultStatementTimeout" value="3000"/>
	</settings>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>  
                <property name="poolMaximumActiveConnections" value="100"/>
                <property name="poolMaximumIdleConnections" value="100"/>
                <property name="poolTimeToWait" value="20000"/>
          </dataSource>
        </environment>
    </environments>
   
    <mappers>
        <mapper resource ="com/psw/exScheduler/mybatis/mapper/board.xml"/>  
    </mappers>
</configuration>

 

 

다음으로 매퍼를 추가합니다. 방금 추가한 mybatis 패키지 안에 mapper라는 패키지를 추가합니다.

board.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="board">
	<select id="selectTest" parameterType="java.util.HashMap" resultType="HashMap">
		select * from board limit 3;
	</select>
</mapper>

간단하게 3개만 board테이블에서 조회해오는 쿼리입니다.

 

 

이제 설정파일들을 읽어들이고 처리할 자바파일을 만들어보겠습니다.

utils라는 패키지를 추가하고 SqlSessionFactorys.java를 생성합니다.

SqlSessionFactorys.java

import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.Properties;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.log4j.Logger;

public class SqlSessionFactorys {
	
	private static final Logger logger = Logger.getLogger(SqlSessionFactorys.class);
	
	private SqlSessionFactorys() {}
	
	static SqlSessionFactorys instance;
	
	private static SqlSession sqlSession;
	
	public static SqlSessionFactorys getInstance() {
		if(instance == null) {
			logger.info("::: SqlSessionFactory Connection "+new Date(System.currentTimeMillis())+" :::");
			
			String resource = "com/psw/exScheduler/mybatis/mybatis-config.xml";
			
			Properties props = new Properties();
			props.put("driver"      , "com.mysql.jdbc.Driver");
			props.put("url"         , "jdbc:mysql://127.0.0.1:3306/db_test?useUnicode=true&amp;characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&amp;defaultFetchSize=1000");
			props.put("username"    , "userName"); //각각 db연결 정보에 맞게 입력		
			props.put("password"    , "password"); //각각 db연결 정보에 맞게 입력

			InputStream inputStream = null;
	        try {
	        	inputStream = Resources.getResourceAsStream(resource);
	        	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, props);
	        	
	        	sqlSession = sqlSessionFactory.openSession(false);
	        	props.clear();
	        }catch(Exception e) {
	        	logger.error(e);
	        }finally {
	        	if(inputStream != null) {
	        		try {
	        			inputStream.close();
	        		}catch(IOException e) {
	        			logger.error(e);
	        		}
	        	}
	        }
		}
		instance = new SqlSessionFactorys();
		
		return instance;
	}
	
	public SqlSession getSqlSession() {
		return sqlSession;
	}
}

싱글톤 형태로 구성하기 위해 생성자는 private처리하여 접근할수 없도록 방지하였고, getInstance 메소드를 통해 최초에 한번만 SqlSessionFactory를 구성하고 담아둘수 있게 구성하였습니다.

 

SqlSession은 연결 후 해당 Class에서 getSqlSession메소드를 통해 가져와서 사용하면 되는 방식입니다.

 

SchedulerTest.java

import java.util.Date;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import com.psw.exScheduler.utils.SqlSessionFactorys;

@DisallowConcurrentExecution
public class SchedulerTest implements Job{
	
	private final Logger logger = Logger.getLogger(SchedulerTest.class);
	
	private static final SqlSession session = SqlSessionFactorys.getInstance().getSqlSession();

	public void execute(JobExecutionContext context) throws JobExecutionException {
		logger.info("::: 스케줄러가 동작합니다.  current Time [" + new Date(System.currentTimeMillis()) + "] :::");
		
		//test select db
		List<Map<Object, Object>> list = session.selectList("board.selectTest");
		for(int i=0; i<list.size(); i++) {
			System.out.println(list.get(i).toString());
		}
	}
}

 

동작 확인

작성이 완료되었으니 실제 동작하는지 확인을 해보겠습니다.

App.java

package kr.or.kisa.ktoaInterlock;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.CronScheduleBuilder.cronSchedule;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;

public class App {
	
	private static final Logger logger = Logger.getLogger(App.class);
	
	private static PropertyReader prop = PropertyReader.getInstance();
	
	public static void main(String[] args){
		//SchedulerFactory Create
		SchedulerFactory schedulerFactory = new StdSchedulerFactory();
		try {
			Scheduler scheduler = schedulerFactory.getScheduler();
			
			JobDetail job = newJob(SchedulerTest.class)
					.withIdentity("jobName", Scheduler.DEFAULT_GROUP)
					.build();
			
			Trigger trigger = newTrigger()
					.withIdentity("triggerName", Scheduler.DEFAULT_GROUP)
					.withSchedule(cronSchedule("0 0 11 * * ?"))
					.build();
			
			scheduler.scheduleJob(job, trigger);
			scheduler.start();
		}catch(Exception e) {
			logger.error("Exception", e);
		}
	}
}

실제 db정보와 연결된 mybatis로 가져온 쿼리 정보입니다.

일치하는것을 확인 할 수 있습니다.

반응형
반응형

https://myhappyman.tistory.com/138

 

JAVA - Maven 프로젝트에서 스케줄러 구성하기(Quartz) - 1

고객사의 요청으로 일정시간마다 특정 DB에서 데이터를 가져오고 넣어주는 작업이 필요했습니다. 일정시간마다 동작이 필요하다보니 자바로 스케줄러를 구성하게 되었고 Quartz 를 사용하여 구��

myhappyman.tistory.com

 

1장에 이어 이번엔 스케줄러에 로그처리를 위해 log4j 설정을 진행해보겠습니다.

 

로그는 실제로 서버나 프로세스를 운용을 하면서 많은 정보를 남겨두어 버그나 문제가 발생하였을때, 원인을 분석할 수 있는 아주 유용한 정보가 될 수 있기에 설정과 처리에 따라 아주 유용한 데이터가 될 수도 있지만, 필요없는 모든 출력문구를 다 찍게해놓으면 분석도 힘들뿐더러 용량만 잔득 차지하는 데이터가 될 수도 있습니다.

 

 

로그 설정(log4j)

pom.xml

<!-- log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

먼저 log4j를 추가합니다.

 

log4j.properties

log4j에 사용할 설정파일을 java디렉토리에 생성하고 설정합니다.(패키지 안에 생성이 아닙니다.)

# Root logger option

#log4j.rootLogger=debug, stdout, logfile
log4j.rootLogger=info, stdout, logfile

# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p (%C{2}:%L) - %m%n

# Direct log message to log file
log4j.appender.logfile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.logfile.DatePattern='.'yyyy-MM-dd
log4j.appender.logfile.File=C:/test/scheduler.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=[%d{yyyy-MM-dd HH:mm:ss}] %5p (%C{2} - %M:%L) - %m%n
log4j.appender.logfile.Append=true

많은 옵션들 중에 log4j.appender.logfile.File 부분에 시스템에 출력할 위치를 지정합니다.

 

저는 C드라이브/test디렉토리에 출력되도록 설정하였습니다.

이후 App.java에 log를 찍어봅니다.

 

App.java

import static org.quartz.CronScheduleBuilder.cronSchedule;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;

import org.apache.log4j.Logger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;

import com.psw.exScheduler.scheduler.SchedulerTest;


public class App {
    private static final Logger logger = Logger.getLogger(App.class);

    public static void main(String[] args) {
        logger.info("Applcation Start!!!");

        // SchedulerFactory Create
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        try {
            Scheduler scheduler = schedulerFactory.getScheduler();

            JobDetail job = newJob(SchedulerTest.class)
                    .withIdentity("jobName", Scheduler.DEFAULT_GROUP)
                    .build();

            // 5 seconds action
            Trigger trigger = newTrigger()
                    .withIdentity("trggerName", Scheduler.DEFAULT_GROUP)
                    .withSchedule(cronSchedule("0/5 * * * * ?"))
                    .build();

            scheduler.scheduleJob(job, trigger);
            scheduler.start();
        } catch (Exception e) {
            logger.error(e);
        }
    }
}

이클립스 콘솔창에 정상적으로 출력되는 모습을 볼 수 있습니다.

 

 

해당 디렉토리에도 log파일이 생성되었고 열어보면 이클립스 콘솔창에 찍었던 로그가 정상적으로 쌓인 모습을 볼 수 있습니다.

반응형
반응형

고객사의 요청으로 일정시간마다 특정 DB에서 데이터를 가져오고 넣어주는 작업이 필요했습니다.

 

일정시간마다 동작이 필요하다보니 자바로 스케줄러를 구성하게 되었고 Quartz를 사용하여 구성해보았습니다.

 

spring 프로젝트에서 was에 스케줄러 추가하여 구성하여도 되지만, 이번 경우엔 간단하게 데이터 처리만 하면 되기때문에 Maven 프로젝트로 생성하여 스케줄러를 구성해보았습니다.

 

 

 

JAVA 스케줄러 구성하기

먼저 Maven프로젝트를 생성하시고 pom.xml에 사용할 라이브러리인 Quartz 정보를 추가합니다.

pom.xml

<!-- scheduler - quartz  --> 
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.0</version>
</dependency>

SchedulerTest.java

import java.util.Date;

import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

@DisallowConcurrentExecution
public class SchedulerTest implements Job{

    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("::: 스케줄러가 동작합니다.  current Time [" + new Date(System.currentTimeMillis()) + "] :::");
    }
}

동작시킬 스케줄러를 구성합니다.

 

SchedulerTest.java 파일을 만들고 Job을 상속받습니다. execute()에 동작시킬 내용을 정의합니다.

 

@DisallowConcurrentExecution 어노테이션은 동기화 처리를 위해 추가하였습니다.

어노테이션을 설정한 해당 스케줄러가 끝나지 않은 상태에서 다음 요청이 들어왔을 경우 대기하고 있게 됩니다.

저같은 경우는 5초마다 동작하는 스케줄러를 구성예정입니다. 하지만 5초안에 스케줄러의 동작이 끝나지 않게 되면 DB 데이터가 꼬일 수 있기때문에 Lock처리를 해두었습니다.

 

App.java

import static org.quartz.CronScheduleBuilder.cronSchedule;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;

public class App{

    public static void main(String[] args) {
        // SchedulerFactory Create
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        try {
            Scheduler scheduler = schedulerFactory.getScheduler();

            JobDetail job = newJob(SchedulerTest.class).withIdentity("jobName", Scheduler.DEFAULT_GROUP).build();

            // 5 seconds action
            Trigger trigger = newTrigger().withIdentity("trggerName", Scheduler.DEFAULT_GROUP)
                    .withSchedule(cronSchedule("0/5 * * * * ?")).build();

            scheduler.scheduleJob(job, trigger);
            scheduler.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

실제로 동작시킬 App.java의 메인문을 구성합니다.

 

먼저 동작시킬 스케줄러를 연결해주고 Trigger부분에서 동작시킬 주기를 설정합니다.

동작주기는 Crontab형태로 입력합니다.

저는 매 5초마다 동작하도록 설정하였고, 동작 결과는 아래와 같습니다.

 

동작결과

 

반응형
반응형
<c:forEach items="${list}" var="list" varStatus="i">
    <tr>
        <td>${list.name }</td>   
        <td>${list.age }</td>   
    </tr>
</c:forEach>

JSP 작성을 하다보면 위 형태로 List 배열 데이터를 넘겨받고 해당 데이터를 파싱하기 위해 forEach를 사용해서 파싱하는 경우가 종종 있다.

 

단순하게 데이터를 출력할때는 변수처리한 var= 값으로 넘기면 쉽게 해결되지만, 종종 자바연산 등을 해서 파싱해야 하는 경우 pageContext.getAttribute("변수값"); 을 통해 처리가 가능하다.

 

사용예시)

<c:forEach items="${list}" var="list" varStatus="i">
    <tr>
        <td>${list.name }</td>
        <td>${list.age }</td>
        <td>
            <%
            UserVO user = (UserVO) pageContext.getAttrinbute("list");
            out.print(user.getDt());
            %>
        </td>
    </tr>
</c:forEach>

연산 로직은 없지만 스크립틀릿(<% %>) 태그를 선언하고 pageContext를 통해 현재의 변수값 list의 데이터값을 VO객체에 넘긴다.

 

이후 원하는 연산 작업(일자계산) 등을 하고 out.print()메소드를 통해 결과 변수를 입력하면 동일하게 jstl내부에서 스크립틀릿을 통해 자바연산까지 사용이 가능하다.

반응형
반응형

java8 LocalDate등을 사용하면 좀 더 쉽게 날짜차이를 구할 수 있지만 아직까지 java 1.7이하를 쓰고 있는 경우가 많다. 7이하버전에서 기준일로부터 금일까지 차이라던지 두 날짜의 값이 있을때 날짜간의 차이를 구해보겠다.

 

두 날짜간의 차이를 구하기 위해서는 해당하는 날짜를 최소단위인 초단위로 변경한 다음 연산을 하고 원하는 일자로 변경하면 되는데, 여기선 getTimeInMillis()를 사용한다. 해당 메소드는 1/1000초로 반환되기 때문에 초단위로 구하기 위해서는 1000으로 나눠주고 일자로 변경하기 위해서는 초로 변경한 값에 (24(시간) * 60(분) * 60(초))를 나눠준다.

 

 

 

오늘부터 특정일자의 차이를 구하기

public class CalTest {

	public static void main(String[] args) throws ParseException {
		Calendar getToday = Calendar.getInstance();
		getToday.setTime(new Date()); //금일 날짜
		
		String s_date = "2020-03-01";
		Date date = new SimpleDateFormat("yyyy-MM-dd").parse(s_date);
		Calendar cmpDate = Calendar.getInstance();
		cmpDate.setTime(date); //특정 일자
		
		long diffSec = (getToday.getTimeInMillis() - cmpDate.getTimeInMillis()) / 1000;
		long diffDays = diffSec / (24*60*60); //일자수 차이
		
		System.out.println(diffSec + "초 차이");
		System.out.println(diffDays + "일 차이");
	}

}

오늘은 포스팅일자인 2020-05-11일을 기준으로 결과값이다.

 

각 해당하는 일자를 ms으로 변경하여 차이값을 구하고 날짜 연산을 통해 차이 일수를 구할 수 있다.😙

반응형
반응형

자바의 Generics(제네릭)이란 다양한 타입의 객체들을 타입체크 해주는 기능을 말한다.
객체들의 타입을 컴파일 시에 체크시키면서 객체의 타입의 안정성과 형변환의 번거로움을 덜어주고 코드들이 간결해진다.

 

제네릭을 알아보기 위해 Person 클래스를 작성해보자.

class Person{
    Object name;
    Object age;

    public void setName(Object name) { this.name = name; }
    public void setAge(Object age) { this.age = age; }
    Object getName(){return name;}
    Object getAge(){return age;}
}

제네릭을 적용하면 어떻게 바뀔까?

 

동일한 Person 클래스가 아래처럼 변경된다.

class Person<T>{
    T name;
    T age;

    public void setName(T name) { this.name = name; }
    public void setAge(T age) { this.age = age; }
    T getName(){return name;}
    T getAge(){return age;}
}

정의하는 클래스 옆에 <T>를 붙였고 Object 자료형을 모두 T로 변경했다.

 

Ttype variable(타입변수) 라고 부른다.

 

임의의 참조형 타입을 뜻하며, 다양한 리턴값이나 매개변수로 Object타입 등을 제공해야하는 하는 경우에 제네릭을 사용함으로써 사용과 동시에 타입을 지정만 해주면 된다.

 

사용은 어떻게 할까?

public static void main(String[] args) {
    Person<Object> p1 = new Person<Object>();
    p1.setAge(21);
    p1.setName("홍길동");

    System.out.println("이름은 " + p1.getName() + " 나이는 " + p1.getAge() + "살 입니다.");
}

결과

기존의 클래스 생성방식은 이미 타입이 지정이 되어 있었다면 제네릭 클래스는 객체를 생성할 때, 타입을 지정해준다.

제네릭 클래스라고해서 지정을 안해준다고 에러가 발생하지는 않지만 경고가 발생한다.

 

반응형
반응형

특정 메소드를 호출하면 return값으로 랜덤으로 생성된 문자열을 만드는 함수를 작성해보았습니다.

 

아스키코드값을 참조하여 작성하였으니, 수정하여 사용하실분들은 아스키코드표를 참조하시면 될 것 같습니다.

값은 0~9의 값과 A~Z까지의 26자리 대문자 문자열만 출력됩니다.

 

랜덤 문자열 생성기

public class RandomOut {

	public static void main(String[] args) {
		System.out.println(getRandomStr(1));
		System.out.println(getRandomStr(2));
		System.out.println(getRandomStr(3));
		System.out.println(getRandomStr(4));
		System.out.println(getRandomStr(5));
		System.out.println(getRandomStr(6));
	}

	public static String getRandomStr(int size) {
		if(size > 0) {
			char[] tmp = new char[size];
			for(int i=0; i<tmp.length; i++) {
				int div = (int) Math.floor( Math.random() * 2 );
				
				if(div == 0) { // 0이면 숫자로
					tmp[i] = (char) (Math.random() * 10 + '0') ;
				}else { //1이면 알파벳
					tmp[i] = (char) (Math.random() * 26 + 'A') ;
				}
			}
			return new String(tmp);
		}
		return "ERROR : Size is required."; 
	}
}

 

 

결과

랜덤 문자열 생성

원하는 자리수만큼 파라미터값으로 입력하시면 자릿수길이의 문자열이 출력됩니다.

 

 

6자리만 6번 생성한경우에도 랜덤값이 잘 출력되는 것을 확인했습니다.

반응형