'Programming/Java' 카테고리의 글 목록 (8 Page)

Programming/Java

jstl(java standard tag library) 2016.02.19
Spring MVC - 값 전달 2016.02.11
Spring - 환경 설정 2016.02.06
Java objects to XML using JAXB (Servlet) 2014.12.04
Spring Security 2014.10.03 1
Camel Header 설정 2014.09.25
Spring Security 적용하기 2014.01.28
Quartz - 배치 실행 2014.01.28

jstl(java standard tag library)

파란크리스마스 2016. 2. 19. 20:57

2016. 2. 19. 20:57

JSTL 라이브러리

접두어	URI 식별자	기능
c	http://java.sun.com/jsp/jstl/core	변수선언
fmt	http://java.sun.com/jsp/jstl/fmt	숫자,날짜,시간을 포맷팅 하는 기능과 국제화, 다국어 지원 기능을 제공
fn	http://java.sun.com/jsp/jstl/functions	문자열을 처리하는 함수를 제공
sql	http://java.sun.com/jsp/jstl/sql	데이터베이스의 데이터를 입력/수정/삭제/조회하는 기능을 제공
x	http://java.sun.com/jsp/jstl/xml	XML 문서를 처리할 때 필요한 기능을 제공
form	http://www.springframework.org/tags/form	Spring MVC에서 form 관련 기능 제공
sec	http://www.springframework.org/security/tags	Spring Security에서 권한 관련 기능 제공

Java objects to XML using JAXB (Servlet)

파란크리스마스 2014. 12. 4. 10:41

2014. 12. 4. 10:41

출처 : JAXB(위키백과)
@XMLAccessorType, @XMLRootElement
JAXB 2.0 Annotation 정리
How to customise an XML export using JAXB
Creating a Generic List Wrapper in JAXB

JAXB(Java Architecture for XML Binding)는 자바 클래스를 XML로 표현하는 자바 API이다. JAXB는 주로 2가지 기능이 있다. 자바 객체를 XML로 직렬화하는 것이고 반대로 XML에서 자바 객체로 역직렬화하는 것이다. 즉, JAXB는 메모리의 데이터를 XML 형식으로 변환하여 저장할 수 있고, 이 과정을 위해 프로그램의 각 클래스에서 XML을 읽고 저장하는 일을 구현해야 한다.

JAXB 2.0 Annotation 정리

@XmlRootElement 속성

name : xml root element 명 지정
namespace: namespace 지정

@XmlAccessorType의 설정

@XmlAccessorType(XmlAccessType.PROPERTY)

모든 getter/setter 쌍을 JAXB 직렬화/역직렬화 대상으로 함
JAXB 직력화/역직력화에서 제외하고자 할 경우 getter 혹은 setter에 @XmlTransient를 사용
@XmlTransient는 getter/setter 상단에 설정

멤버변수 상단에 설정시 적용 않됨

getter/setter가 존재하지 않는 public 멤버 변수를 JAXB 직력화/역직력화에서 추가하고자 할 경우 JAXB 어노테이션 사용

@XmlElement
@XmlAttribute

Employee

package com.test;

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;

@XmlRootElement(name = "Emp")
@XmlType(propOrder = {"name", "age", "role", "gender"})
public class Employee {

	private int id;

	private String gender;

	private int age;
	private String name;
	private String role;

	private String password;

	@XmlTransient
	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	@XmlAttribute
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@XmlElement(name = "gen")
	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public String getRole() {
		return role;
	}

	public void setRole(String role) {
		this.role = role;
	}

	@Override
	public String toString() {
		return "ID = " + id + " NAME=" + name + " AGE=" + age + " GENDER="
				+ gender + " ROLE=" + role + " PASSWORD=" + password;
	}

}

JAXBExample

package com.test;

import java.io.File;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

public class JAXBExample {

	private static final String FILE_NAME = "jaxb-emp.xml";

	public static void main(String[] args) {
		Employee emp = new Employee();
		emp.setId(1);
		emp.setAge(25);
		emp.setName("Pankaj");
		emp.setGender("Male");
		emp.setRole("Developer");
		emp.setPassword("sensitive");

		jaxbObjectToXML(emp);

		Employee empFromFile = jaxbXMLToObject();
		System.out.println(empFromFile.toString());
	}

	private static Employee jaxbXMLToObject() {
		try {
			JAXBContext context = JAXBContext.newInstance(Employee.class);
			Unmarshaller un = context.createUnmarshaller();
			Employee emp = (Employee) un.unmarshal(new File(FILE_NAME));
			return emp;
		} catch (JAXBException e) {
			e.printStackTrace();
		}
		return null;
	}

	private static void jaxbObjectToXML(Employee emp) {

		try {
			JAXBContext context = JAXBContext.newInstance(Employee.class);
			Marshaller m = context.createMarshaller();
			// for pretty-print XML in JAXB
			m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

			// Write to System.out for debugging
			// m.marshal(emp, System.out);

			// Write to File
			m.marshal(emp, new File(FILE_NAME));
		} catch (JAXBException e) {
			e.printStackTrace();
		}
	}

}

결과 파일 : jaxb-emp.xml

JAXBExample에서 Employee 클래스에 데이터를 담고, 그것을 xml로 출력한 결과입니다.

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Emp id="1">
    <name>Pankaj</name>
    <age>25</age>
    <role>Developer</role>
    <gen>Male</gen>
</Emp>

Wrapper

package com.test;

import java.util.ArrayList;
import java.util.List;

import javax.xml.bind.annotation.XmlAnyElement;

public class Wrapper<T> {
	private List<T> items;

	public Wrapper() {
		items = new ArrayList<T>();
	}

	public Wrapper(List<T> items) {
		this.items = items;
	}

	@XmlAnyElement(lax = true)
	public List<T> getItems() {
		return items;
	}
}

XMLServlet

package com.test;

import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.namespace.QName;
import javax.xml.transform.stream.StreamSource;

@WebServlet(urlPatterns = "/xml")
public class XMLServlet extends HttpServlet {

	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		resp.setContentType("text/xml;charset=UTF-8");
		OutputStream out = resp.getOutputStream();

		try {
			JAXBContext jc = JAXBContext.newInstance(Wrapper.class, Employee.class);
			
			// Marshal
			Marshaller marshaller;
			
			marshaller = jc.createMarshaller();
			marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
			marshal(marshaller, getEmpDatas(), "emps", out);

		} catch (JAXBException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		out.close();
	}

	/** * Unmarshal XML to Wrapper and return List value. */
	private static <T> List<T> unmarshal(Unmarshaller unmarshaller, Class<T> clazz, String xmlLocation) throws JAXBException {
		StreamSource xml = new StreamSource(xmlLocation);
		Wrapper<T> wrapper = (Wrapper<T>) unmarshaller.unmarshal(xml, Wrapper.class).getValue();
		return wrapper.getItems();
	}

	/**
	 * * Wrap List in Wrapper, then leverage JAXBElement to supply root element *
	 * information.
	 */
	private static void marshal(Marshaller marshaller, List<?> list, String name, OutputStream os) throws JAXBException {
		QName qName = new QName(name);
		Wrapper wrapper = new Wrapper(list);
		JAXBElement<Wrapper> jaxbElement = new JAXBElement<Wrapper>(qName, Wrapper.class, wrapper);
		marshaller.marshal(jaxbElement, os);
	}

	private List<Employee> getEmpDatas() {

		List<Employee> datas = new ArrayList<Employee>();

		Employee emp = new Employee();
		emp.setId(1);
		emp.setAge(25);
		emp.setName("Pankaj");
		emp.setGender("Male");
		emp.setRole("Developer");
		emp.setPassword("sensitive");

		datas.add(emp);

		emp = new Employee();
		emp.setId(11);
		emp.setAge(125);
		emp.setName("1Pankaj");
		emp.setGender("1Male");
		emp.setRole("1Developer");
		emp.setPassword("1sensitive");

		datas.add(emp);

		return datas;
	}
}

실행결과

소스파일

ObjToXML.zip

Spring Security

파란크리스마스 2014. 10. 3. 08:03

2014. 10. 3. 08:03

출처 : Spring Security login/logout 관련 글
Spring Security Logout Example
Spring Security 3 - 맛보기와 기본 설정의 이해

web.xml

	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			/WEB-INF/baroCOST-datasource.xml
			/WEB-INF/baroCOST-security.xml
		</param-value>
	</context-param>
	
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	
	<filter>
		<filter-name>springSecurityFilterChain</filter-name>
		<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>springSecurityFilterChain</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

baroCOST-security.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:security="http://www.springframework.org/schema/security"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
           http://www.springframework.org/schema/security
           http://www.springframework.org/schema/security/spring-security-3.2.xsd">

	<security:http auto-config="true">
		<security:intercept-url pattern="/favicon.ico" access="ROLE_ANONYMOUS" />
		<security:intercept-url pattern="/**" access="ROLE_USER" />
	</security:http>

	<security:authentication-manager>
		<security:authentication-provider>
			<security:user-service>
				<security:user name="guest" password="guest" authorities="ROLE_USER" />
			</security:user-service>
		</security:authentication-provider>
	</security:authentication-manager>
</beans>

Spring Security 에서 기본 제공해주는 로그인 페이지(spring_security_login)

<html><head><title>Login Page</title></head><body onload='document.f.j_username.focus();'>
<h3>Login with Username and Password</h3>
<form name='f' action='/baroCOST/j_spring_security_check' method='POST'>
 <table>
    <tr><td>User:</td><td><input type='text' name='j_username' value=''></td></tr>
    <tr><td>Password:</td><td><input type='password' name='j_password'/></td></tr>
    <tr><td colspan='2'><input name="submit" type="submit" value="Login"/></td></tr>
  </table>
</form></body></html>

DB 사용

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:security="http://www.springframework.org/schema/security"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
           http://www.springframework.org/schema/security
           http://www.springframework.org/schema/security/spring-security-3.2.xsd">

	<security:http auto-config="true">
		<security:intercept-url pattern="/favicon.ico" access="ROLE_ANONYMOUS" />
		<security:intercept-url pattern="/**" access="ROLE_USER" />
		<security:intercept-url pattern="/" access="ROLE_USER" />
	</security:http>

	<security:authentication-manager>
		<security:authentication-provider>
			<!-- 
            <security:user-service>
                <security:user name="guest" password="guest" authorities="ROLE_USER" />
            </security:user-service>
            -->		
			<security:jdbc-user-service data-source-ref="dataSource"
				users-by-username-query="select user_id username, password, 1 as enabled from user_info where user_id = ?"
				authorities-by-username-query="select user_id username, 'ROLE_USER' authority from user_info where user_id = ?"
			/>
		</security:authentication-provider>
	</security:authentication-manager>
</beans>

로그인 페이지 변경

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:security="http://www.springframework.org/schema/security"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
           http://www.springframework.org/schema/security
           http://www.springframework.org/schema/security/spring-security-3.2.xsd">
           
	<security:http pattern="/common/css/**" security="none" />
	<security:http pattern="/common/image/**" security="none" />
	<security:http pattern="/common/js/**" security="none" />           

	<security:http auto-config="true">
		<security:intercept-url pattern="/favicon.ico" access="ROLE_ANONYMOUS" />
		<security:intercept-url pattern="/login.cmx" access="ROLE_ANONYMOUS" />
		<security:intercept-url pattern="/**" access="ROLE_USER" />
		<security:intercept-url pattern="/" access="ROLE_USER" />
		
		<security:form-login login-page="/login.cmx" default-target-url="/index.html"
			authentication-failure-url="/loginfailed" />
		<security:logout logout-success-url="/logout" />		
	</security:http>

	<security:authentication-manager>
		<security:authentication-provider>
			<!-- 
            <security:user-service>
                <security:user name="guest" password="guest" authorities="ROLE_USER" />
            </security:user-service>
            -->		
			<security:jdbc-user-service data-source-ref="dataSource"
				users-by-username-query="select user_id username, password, 1 as enabled from user_info where user_id = ?"
				authorities-by-username-query="select user_id username, 'ROLE_USER' authority from user_info where user_id = ?"
			/>
		</security:authentication-provider>
	</security:authentication-manager>
</beans>

Camel Header 설정

파란크리스마스 2014. 9. 25. 10:19

2014. 9. 25. 10:19

참고 : http://camel.apache.org/jms.html

RouteBuilder

	from("jms:queue:test1?maxConcurrentConsumers=1&maxMessagesPerTask=1&autoStartup=true&preserveMessageQos=true")
	.bean(com.bluexmas.Test1Queue.class, "doTest")
	.to("jms:queue:test2");
	
	from("jms:queue:test2?maxConcurrentConsumers=1&maxMessagesPerTask=1&autoStartup=true&preserveMessageQos=true")
	.bean(com.bluexmas.Test2Queue.class, "doTest")
	.to("stream:out");

Header1Object

package com.bluexmas;

import java.io.Serializable;

public class Header1Object implements Serializable {
	
	private static final long serialVersionUID = 1L;
	
	int age;
	String name;
	
	public Header1Object(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}

	@Override
	public String toString() {
		return "Header1Object [age=" + age + ", name=" + name + "]";
	}
}

Test1Queue

package com.bluexmas;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.camel.Exchange;
import org.apache.camel.Message;

import com.uni.fep.bean.service.MQSenderService;
import com.uni.fep.bean.util.BeanUtils;
import com.uni.fep.bean.util.EnvironmentInit;

public class Test1Queue {
	
	public void doTest(Exchange exchange) {
		System.out.println("-- Test1Queue.doTest ----------------------------");
		
		Message in = exchange.getIn();
		
		System.out.println("body = " + in.getBody());
		System.out.println("header1 = " + in.getHeader("header1"));
		System.out.println("header2 = " + in.getHeader("header2"));
		
		in.setHeader("header1", "value1-1");
		in.setHeader("header2", "value2");
		
		List<String> listValue = new ArrayList<String>();
		listValue.add("list1");
		listValue.add("list2");
		in.setHeader("header3", listValue);
		System.out.println("header3 = " + in.getHeader("header3"));
		
		in.setHeader("header4", new Header1Object(10, "bluexmas"));
		System.out.println("header4 = " + in.getHeader("header4"));
	}
	
	public static void main(String[] args) throws Exception {
		EnvironmentInit.init();
		
		MQSenderService service = (MQSenderService)BeanUtils.getBean("MQSenderService");
		
		String message = "Hello Camel";
		
		Map<String, Object>map=new HashMap<String,Object>();
		map.put("header1", "value1");
		
		service.doSend("test1", map, message);
		
		Thread.sleep(5000);
		
		System.exit(0);
	}

}

Test2Queue

package com.bluexmas;

import org.apache.camel.Exchange;
import org.apache.camel.Message;

public class Test2Queue {

	public void doTest(Exchange exchange) {
		System.out.println("-- Test2Queue.doTest ----------------------------");
		
		Message in = exchange.getIn();
		
		System.out.println("body = " + in.getBody());
		System.out.println("header1 = " + in.getHeader("header1"));
		System.out.println("header2 = " + in.getHeader("header2"));
		System.out.println("header3 = " + in.getHeader("header3"));
		System.out.println("header4 = " + in.getHeader("header4"));
	}
	
}

출력결과

-- Test1Queue.doTest ----------------------------
body = Hello Camel
header1 = value1
header2 = null
header3 = [list1, list2]
header4 = Header1Object [age=10, name=bluexmas]
-- Test2Queue.doTest ----------------------------
body = Hello Camel
header1 = value1-1
header2 = value2
header3 = null
header4 = null
Hello Camel

설명

Camel에서 기본적으로 Header의 내용은 Queue 넘어 갈때 초기화 되는데,
초기화 하지 않고, 그대로 데이터를 가지고 다니려면 preserveMessageQos=true 해주면 된다.

출력결과를 보시면 알 수 있듯이 기본 자료형외에 객체는 전달 할 수가 없는 것으로 판단된다.

header1 : 초기에 전달된 Header의 값으로 그 값을 변경했을때 변경된 값이 전달되는 것을 확인
header2 : 초기에 전달되지 않았으나 추가로 Header에 추가된 값으로 Queue 이동 후 값이 존재하는 것을 확인
Header3 : ArreyList에 기본형 데이터(String) 추가해서 Header에 추가해서 전달했으나 List 전달되지 않는 것으로 확인
Header4 : 사용자가 임으로 만들 객체를 Header에 추가 했으나 Queue 이동 후 값이 전달되지 않는 것으로 확인

Spring Security 적용하기

파란크리스마스 2014. 1. 28. 15:33

2014. 1. 28. 15:33

출처 : Spring Security 3 - 맛보기와 기본 설정의 이해
스프링 시큐리티 적용하기 (properties 인증 방법)
Spring Security를 이용한 인증 처리
AJAX Login with Spring Security

WEB-INF\web.xml

	<!-- 스프링 시큐리티 적용하기 -->
	<context-param&g
		<param-name>contextConfigLocation</param-name>
		<param-value>WEB-INF/spring-security.xml</param-value>
 	</context-param>	
	<filter>
		<filter-name>springSecurityFilterChain</filter-name>
		<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>springSecurityFilterChain</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	<listener>
  		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 	</listener>

WEB-INF\spring-security.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:security="http://www.springframework.org/schema/security"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
           http://www.springframework.org/schema/security
           http://www.springframework.org/schema/security/spring-security-3.2.xsd">

	<security:http pattern="/common/css/**" security="none" />
	<security:http pattern="/common/img/**" security="none" />
	<security:http pattern="/common/js/**" security="none" />

	<security:http auto-config="true">
		<security:intercept-url pattern="/admin/**"	access="ROLE_ADMIN" />
		<security:intercept-url pattern="/**" access="IS_AUTHENTICATED_ANONYMOUSLY" />		

		<!-- 
		<security:form-login login-page="/login.do"
			login-processing-url="/j_spring_security_check.do"
			default-target-url="/loginSuccess.do" authentication-failure-url="/loginFailed.do" />

		<security:logout logout-url="/j_spring_security_logout.do"
			logout-success-url="/logout.do" invalidate-session="true" />
 		-->			
	</security:http>


	<security:authentication-manager>
		<security:authentication-provider>
            <security:user-service>
                <security:user name="admin" password="admin!@" authorities="ROLE_ADMIN" />
            </security:user-service>		
			<!-- 
			<security:user-service properties="/WEB-INF/users-config.xml" />
			 -->
		</security:authentication-provider>
	</security:authentication-manager>

</beans>

WEB-INF\users-config.xml (옵션)

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
        <comment>users</comment>
        <entry key="admin">1111,ROLE_ADMIN,ROLE_USER</entry>
        <entry key="user">2222,ROLE_USER</entry>
</properties>

Quartz - 배치 실행

파란크리스마스 2014. 1. 28. 14:45

2014. 1. 28. 14:45

출처 : Chapter 19. Quartz 혹은 Timer 를 사용한 스케쥴링

DongHoReportBatch.java

package com.blueX.batch;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class DongHoReportBatch extends QuartzJobBean {

	@Override
	protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
		Date dt = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd, hh:mm:ss a"); 
		System.out.println(sdf.format(dt).toString()); 
	}
	
	public static void main(String[] args) throws Exception {
		String[] configLocation = new String[] { "file:WebContent/WEB-INF/blueX-servlet.xml" };
		ApplicationContext context = new ClassPathXmlApplicationContext(configLocation);
	}

}

blueX-servlet.xml

	<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean" autowire="no">
		<property name="triggers">
       		<list>
	         	<ref bean="dongHoReportTrigger" />
			</list>
     	</property>
     	<property name="quartzProperties">
		    <props>
		    	<prop key="org.quartz.threadPool.class">org.quartz.simpl.SimpleThreadPool</prop>
		        <prop key="org.quartz.threadPool.threadCount">5</prop>
		        <prop key="org.quartz.threadPool.threadPriority">4</prop>
		        <prop key="org.quartz.jobStore.class">org.quartz.simpl.RAMJobStore</prop>
		        <prop key="org.quartz.jobStore.misfireThreshold">60000</prop>
			</props>
		</property>
	</bean>
	
	<bean id="dongHoReportTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
		<property name="jobDetail" ref="dongHoReportJob" />
		<property name="startDelay" value="60000"/> <!-- 서버 시작후 1분후 첫 실행 -->
		<property name="repeatInterval" value="300000"/> <!-- 첫 실행 후 5분 마다 실행 -->
	</bean> 
	
	<bean id="dongHoReportJob" class="org.springframework.scheduling.quartz.JobDetailBean">
		<property name="jobClass" value="com.blueX.batch.DongHoReportBatch" />
	</bean>

PREV 이전 1 ···5 6 7 8 9 10 11 12 NEXT 다음

파란크리스마스