Monthly Archives: 8月 2013

29
8月

HttpServletResponseWrapper 샘플

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.LinkedHashMap;
import java.util.Map;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

public class MyResponseWrapper extends HttpServletResponseWrapper {

	private int statusCode=200;

	private ByteArrayOutputStream buffer = new ByteArrayOutputStream();
	private PrintWriter writer = null;
	private ServletOutputStream sos = null;
	
	private Map<String, String> headerMaps = new LinkedHashMap<String, String>();

	public MyResponseWrapper(HttpServletResponse response) {
        super(response);
    }

	public int getStatusCode() {
		return statusCode;
	}

	public Map<String, String> getHeaderMaps() {
		return headerMaps;
	}

	public String getResponseText(){
		if ( writer != null ) writer.flush();
		return buffer.toString();
	}

	public byte[] getResponseBinary(){
		if ( writer != null ) writer.flush();
		return buffer.toByteArray();
	}

	@Override
	public ServletOutputStream getOutputStream() throws IOException {
		if ( sos == null ) {
			sos = new MyServletOutputStream(buffer);
		}
		return sos;
	}

	@Override
	public PrintWriter getWriter(){
		try {
			writer = new PrintWriter(new OutputStreamWriter(buffer, "utf-8"));
			return writer;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	@Override
	public void addIntHeader(String name, int value) {
		headerMaps.put(name, String.valueOf(value));
		super.addIntHeader(name, value);
	}

	@Override
	public void setHeader(String name, String value) {
		headerMaps.put(name, value);
		super.setHeader(name, value);
	}

	@Override
	public void setIntHeader(String name, int value) {
		headerMaps.put(name, String.valueOf(value));
		super.setIntHeader(name, value);
	}

	@Override
	public void addHeader(String name, String value) {
		headerMaps.put(name, value);
		super.addHeader(name, value);
	}

	@Override
	public void sendError(int sc) throws IOException {
		statusCode=sc;
		super.sendError(sc);
	}

	@Override
	public void setStatus(int sc) {
		statusCode=sc;
		super.setStatus(sc);
	}

	@Override
	public void sendError(int sc, String msg) throws IOException {
		statusCode=sc;
		super.sendError(sc, msg);
	}

	@Override
	public void setStatus(int sc, String sm) {
		statusCode=sc;
		super.setStatus(sc, sm);
	}

	@Override
	public void sendRedirect(String location) throws IOException {
		statusCode=302;
		setHeader("location", location);
		setStatus(302);
		//응답이 커밋되어 버리므로 아래를 사용해서는 안됩니다.
		//super.sendRedirect(location);
	}

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.util.LinkedHashMap;

import java.util.Map;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpServletResponseWrapper;

public class MyResponseWrapper extends HttpServletResponseWrapper {

private int statusCode=200;

private ByteArrayOutputStream buffer = new ByteArrayOutputStream();

private PrintWriter writer = null;

private ServletOutputStream sos = null;

private Map<String, String> headerMaps = new LinkedHashMap<String, String>();

public MyResponseWrapper(HttpServletResponse response) {

super(response);

}

public int getStatusCode() {

return statusCode;

}

public Map<String, String> getHeaderMaps() {

return headerMaps;

}

public String getResponseText(){

if ( writer != null ) writer.flush();

return buffer.toString();

}

public byte[] getResponseBinary(){

if ( writer != null ) writer.flush();

return buffer.toByteArray();

}

@Override

public ServletOutputStream getOutputStream() throws IOException {

if ( sos == null ) {

sos = new MyServletOutputStream(buffer);

}

return sos;

}

@Override

public PrintWriter getWriter(){

try {

writer = new PrintWriter(new OutputStreamWriter(buffer, "utf-8"));

return writer;

} catch (Exception e) {

throw new RuntimeException(e);

}

@Override

public void addIntHeader(String name, int value) {

headerMaps.put(name, String.valueOf(value));

super.addIntHeader(name, value);

}

@Override

public void setHeader(String name, String value) {

headerMaps.put(name, value);

super.setHeader(name, value);

}

@Override

public void setIntHeader(String name, int value) {

headerMaps.put(name, String.valueOf(value));

super.setIntHeader(name, value);

}

@Override

public void addHeader(String name, String value) {

headerMaps.put(name, value);

super.addHeader(name, value);

}

@Override

public void sendError(int sc) throws IOException {

statusCode=sc;

super.sendError(sc);

}

@Override

public void setStatus(int sc) {

statusCode=sc;

super.setStatus(sc);

}

@Override

public void sendError(int sc, String msg) throws IOException {

statusCode=sc;

super.sendError(sc, msg);

}

@Override

public void setStatus(int sc, String sm) {

statusCode=sc;

super.setStatus(sc, sm);

}

@Override

public void sendRedirect(String location) throws IOException {

statusCode=302;

setHeader("location", location);

setStatus(302);

//응답이 커밋되어 버리므로 아래를 사용해서는 안됩니다.

//super.sendRedirect(location);

}

MyServletOutputS … Continue reading →

Posted in Java | コメントは受け付けていません。

27
8月

Seam에서 EntityManager 생성하는 녀석

//$Id: ManagedPersistenceContext.java 11990 2010-01-25 23:55:21Z manaRH $
package org.jboss.seam.persistence;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.naming.NamingException;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.servlet.http.HttpSessionActivationListener;
import javax.servlet.http.HttpSessionEvent;
import javax.transaction.Synchronization;
import javax.transaction.SystemException;

import org.jboss.seam.Component;
import org.jboss.seam.ScopeType;
import org.jboss.seam.annotations.Create;
import org.jboss.seam.annotations.Destroy;
import org.jboss.seam.annotations.FlushModeType;
import org.jboss.seam.annotations.Install;
import org.jboss.seam.annotations.Scope;
import org.jboss.seam.annotations.Unwrap;
import org.jboss.seam.annotations.intercept.BypassInterceptors;
import org.jboss.seam.contexts.Contexts;
import org.jboss.seam.contexts.Lifecycle;
import org.jboss.seam.core.Mutable;
import org.jboss.seam.core.Expressions.ValueExpression;
import org.jboss.seam.log.LogProvider;
import org.jboss.seam.log.Logging;
import org.jboss.seam.transaction.Transaction;
import org.jboss.seam.transaction.UserTransaction;
import org.jboss.seam.util.Naming;

/**
 * A Seam component that manages a conversation-scoped extended
 * persistence context that can be shared by arbitrary other
 * components.
 * 
 * @author Gavin King
 */
@Scope(ScopeType.CONVERSATION)
@BypassInterceptors
@Install(false)
public class ManagedPersistenceContext 
   implements Serializable, HttpSessionActivationListener, Mutable, PersistenceContextManager, Synchronization
{
   private static final long serialVersionUID = -4972387440275848126L;
   private static final LogProvider log = Logging.getLogProvider(ManagedPersistenceContext.class);
   
   private transient EntityManager entityManager;
   private String persistenceUnitJndiName;
   private String componentName;
   private ValueExpression<EntityManagerFactory> entityManagerFactory;
   private List<Filter> filters = new ArrayList<Filter>(0);
   
   private transient boolean synchronizationRegistered;
   private transient boolean destroyed;
  
   public boolean clearDirty()
   {
      return true;
   }
   
   @Create
   public void create(Component component)
   {
      this.componentName = component.getName();
      if (persistenceUnitJndiName==null)
      {
         persistenceUnitJndiName = "java:/" + componentName;
      }
      
      PersistenceContexts.instance().touch(componentName);      
   }
   
   private void initEntityManager()
   {
      entityManager = getEntityManagerFactoryFromJndiOrValueBinding().createEntityManager();
      PersistenceProvider persistenceProvider = PersistenceProvider.instance();
      entityManager = persistenceProvider.proxyEntityManager(entityManager);
      setEntityManagerFlushMode( PersistenceContexts.instance().getFlushMode() );

      for (Filter f: filters)
      {
         if ( f.isFilterEnabled() )
         {
            persistenceProvider.enableFilter(f, entityManager);
         }
      }

      if ( log.isDebugEnabled() )
      {
         if (entityManagerFactory==null)
         {
            log.debug("created seam managed persistence context for persistence unit: "+ persistenceUnitJndiName);
         }
         else 
         {
            log.debug("created seam managed persistence context from EntityManagerFactory");
         }
      }
   }
   
   @Unwrap
   public EntityManager getEntityManager() throws NamingException, SystemException
   {
      if (entityManager==null) initEntityManager();
      
      if ( !synchronizationRegistered && !Lifecycle.isDestroying() )
      {
         joinTransaction();
      }
      
      return entityManager;
   }

   private void joinTransaction() throws SystemException
   {
      UserTransaction transaction = Transaction.instance();
      if ( transaction.isActive() )
      {
         transaction.enlist(entityManager);
         try
         {
            transaction.registerSynchronization(this);
            synchronizationRegistered = true;
         }
         catch (Exception e)
         {
            synchronizationRegistered = PersistenceProvider.instance().registerSynchronization(this, entityManager);
         }
      }
   }
   
   /**
    * If a transaction is active, fail the passivation. The field holding the
    * managed EntityManager is marked as transient so that it is not serialized
    * (it can't be). The transient keyword was choosen because we don't want to
    * forcefully close and nullify the EntityManager on every request because
    * then we have to keep hitting the database to load the entities back into
    * the persistence context. The only downside is that we cannot clean up
    * on the old node before the session hops, but it turns out not to matter.
    * 
    * Note that we must use the method on the
    * {@link HttpSessionActivationListener} interface rather than
    * <code>@PrePassivate</code> since interceptors are disabled on this component.
    */
   public void sessionWillPassivate(HttpSessionEvent event)
   {
      if (synchronizationRegistered)
      {
         throw new IllegalStateException("cannot passivate persistence context with active transaction");
      }
   }
   
   /**
    * Note that we must use the method on the {@link HttpSessionActivationListener}
    * interface rather than @PostActivate since interceptors are disabled
    * on this component.
    */
   public void sessionDidActivate(HttpSessionEvent event) {}
   
   @Destroy
   public void destroy()
   {
      destroyed = true;
      if ( !synchronizationRegistered )
      {
         //in requests that come through SeamPhaseListener,
         //there can be multiple transactions per request,
         //but they are all completed by the time contexts
         //are destroyed
         //so wait until the end of the request to close
         //the session
         //on the other hand, if we are still waiting for
         //the transaction to commit, leave it open
         close();
      }
      PersistenceContexts.instance().untouch(componentName);
   }

   public void afterCompletion(int status)
   {
      synchronizationRegistered = false;
      //if ( !Contexts.isConversationContextActive() )
      if (destroyed)
      {
         //in calls to MDBs and remote calls to SBs, the 
         //transaction doesn't commit until after contexts
         //are destroyed, so wait until the transaction
         //completes before closing the session
         //on the other hand, if we still have an active
         //conversation context, leave it open
         close();
      }
   }
   
   public void beforeCompletion() {}
   
   private void close()
   {
      if (Contexts.isEventContextActive()) 
      {

         boolean transactionActive = false;
         
         try
         {
            UserTransaction tx = Transaction.instance();
            try 
            {
               transactionActive = tx.isActive();
            }
            catch (SystemException se)
            {
               log.debug("could not get transaction status while destroying persistence context");
            }
         }
         catch (Exception e)
         {
            // WebSphere throws a javax.naming.ConfigurationException when Transaction.instance() is called during HTTP Session expiration 
            // and there is no JNDI lookup possible. See details there: JBSEAM-4332
            log.warn("could not get transaction while destroying persistence context. (called during session expiration ?)");
         }
         
         if ( transactionActive )
         {
            throw new IllegalStateException("attempting to destroy the persistence context while an active transaction exists (try installing <transaction:ejb-transaction/>)");
         }
      }
      
      if ( log.isDebugEnabled() )
      {
         log.debug("destroying seam managed persistence context for persistence unit: " + persistenceUnitJndiName);
      }
      
      if (entityManager!=null && entityManager.isOpen())
      {
         entityManager.close();
      }
   }
   
   public EntityManagerFactory getEntityManagerFactoryFromJndiOrValueBinding()
   {
      EntityManagerFactory result = null;
      //first try to find it via the value binding
      if (entityManagerFactory!=null)
      {
         result = entityManagerFactory.getValue();
      }
      //if its not there, try JNDI
      if (result==null)
      {
         try
         {
            result = (EntityManagerFactory) Naming.getInitialContext().lookup(persistenceUnitJndiName);
         }
         catch (NamingException ne)
         {
            throw new IllegalArgumentException("EntityManagerFactory not found in JNDI : " + persistenceUnitJndiName, ne);
         }
      }
      return result;
   }
   
   /**
    * A value binding expression that returns an EntityManagerFactory,
    * for use of JPA outside of Java EE 5 / Embeddable EJB3.
    */
   public ValueExpression<EntityManagerFactory> getEntityManagerFactory()
   {
      return entityManagerFactory;
   }
   
   public void setEntityManagerFactory(ValueExpression<EntityManagerFactory> entityManagerFactory)
   {
      this.entityManagerFactory = entityManagerFactory;
   }
   
   /**
    * The JNDI name of the EntityManagerFactory, for 
    * use of JPA in Java EE 5 / Embeddable EJB3.
    */
   public String getPersistenceUnitJndiName()
   {
      return persistenceUnitJndiName;
   }
   
   public void setPersistenceUnitJndiName(String persistenceUnitName)
   {
      this.persistenceUnitJndiName = persistenceUnitName;
   }
   
   public String getComponentName() 
   {
      return componentName;
   }
   
   /**
    * Hibernate filters to enable automatically
    */
   public List<Filter> getFilters()
   {
      return filters;
   }
   
   public void setFilters(List<Filter> filters)
   {
      this.filters = filters;
   }
   
   public void changeFlushMode(FlushModeType flushMode)
   {
      if (entityManager!=null && entityManager.isOpen())
      {
         setEntityManagerFlushMode(flushMode);
      }
   }
   
   protected void setEntityManagerFlushMode(FlushModeType flushMode)
   {
      switch (flushMode)
      {
         case AUTO:
            entityManager.setFlushMode(javax.persistence.FlushModeType.AUTO);
            break;
         case COMMIT:
            entityManager.setFlushMode(javax.persistence.FlushModeType.COMMIT);
            break;
         case MANUAL:
            PersistenceProvider.instance().setFlushModeManual(entityManager);
            break;
      }
   }
   
   @Override
   public String toString()
   {
      return "ManagedPersistenceContext(" + persistenceUnitJndiName + ")";
   }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

//$Id: ManagedPersistenceContext.java 11990 2010-01-25 23:55:21Z manaRH $

package org.jboss.seam.persistence;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.List;

import javax.naming.NamingException;

import javax.persistence.EntityManager;

import javax.persistence.EntityManagerFactory;

import javax.servlet.http.HttpSessionActivationListener;

import javax.servlet.http.HttpSessionEvent;

import javax.transaction.Synchronization;

import javax.transaction.SystemException;

import org.jboss.seam.Component;

import org.jboss.seam.ScopeType;

import org.jboss.seam.annotations.Create;

import org.jboss.seam.annotations.Destroy;

import org.jboss.seam.annotations.FlushModeType;

import org.jboss.seam.annotations.Install;

import org.jboss.seam.annotations.Scope;

import org.jboss.seam.annotations.Unwrap;

import org.jboss.seam.annotations.intercept.BypassInterceptors;

import org.jboss.seam.contexts.Contexts;

import org.jboss.seam.contexts.Lifecycle;

import org.jboss.seam.core.Mutable;

import org.jboss.seam.core.Expressions.ValueExpression;

import org.jboss.seam.log.LogProvider;

import org.jboss.seam.log.Logging;

import org.jboss.seam.transaction.Transaction;

import org.jboss.seam.transaction.UserTransaction;

import org.jboss.seam.util.Naming;

/**

* A Seam component that manages a conversation-scoped extended

* persistence context that can be shared by arbitrary other

* components.

* @author Gavin King

@Scope(ScopeType.CONVERSATION)

@BypassInterceptors

@Install(false)

public class ManagedPersistenceContext

implements Serializable, HttpSessionActivationListener, Mutable, PersistenceContextManager, Synchronization

{

private static final long serialVersionUID = -4972387440275848126L;

private static final LogProvider log = Logging.getLogProvider(ManagedPersistenceContext.class);

private transient EntityManager entityManager;

private String persistenceUnitJndiName;

private String componentName;

private ValueExpression<EntityManagerFactory> entityManagerFactory;

private List<Filter> filters = new ArrayList<Filter>(0);

private transient boolean synchronizationRegistered;

private transient boolean destroyed;

public boolean clearDirty()

{

return true;

}

@Create

public void create(Component component)

{

this.componentName = component.getName();

if (persistenceUnitJndiName==null)

{

persistenceUnitJndiName = "java:/" + componentName;

}

PersistenceContexts.instance().touch(componentName);

}

private void initEntityManager()

{

entityManager = getEntityManagerFactoryFromJndiOrValueBinding().createEntityManager();

PersistenceProvider persistenceProvider = PersistenceProvider.instance();

entityManager = persistenceProvider.proxyEntityManager(entityManager);

setEntityManagerFlushMode( PersistenceContexts.instance().getFlushMode() );

for (Filter f: filters)

{

if ( f.isFilterEnabled() )

{

persistenceProvider.enableFilter(f, entityManager);

}

if ( log.isDebugEnabled() )

{

if (entityManagerFactory==null)

{

log.debug("created seam managed persistence context for persistence unit: "+ persistenceUnitJndiName);

}

else

{

log.debug("created seam managed persistence context from EntityManagerFactory");

}

@Unwrap

public EntityManager getEntityManager() throws NamingException, SystemException

{

if (entityManager==null) initEntityManager();

if ( !synchronizationRegistered && !Lifecycle.isDestroying() )

{

joinTransaction();

}

return entityManager;

}

private void joinTransaction() throws SystemException

{

UserTransaction transaction = Transaction.instance();

if ( transaction.isActive() )

{

transaction.enlist(entityManager);

try

{

transaction.registerSynchronization(this);

synchronizationRegistered = true;

}

catch (Exception e)

{

synchronizationRegistered = PersistenceProvider.instance().registerSynchronization(this, entityManager);

}

/**

* If a transaction is active, fail the passivation. The field holding the

* managed EntityManager is marked as transient so that it is not serialized

* (it can't be). The transient keyword was choosen because we don't want to

* forcefully close and nullify the EntityManager on every request because

* then we have to keep hitting the database to load the entities back into

* the persistence context. The only downside is that we cannot clean up

* on the old node before the session hops, but it turns out not to matter.

* Note that we must use the method on the

* {@link HttpSessionActivationListener} interface rather than

* <code>@PrePassivate</code> since interceptors are disabled on this component.

public void sessionWillPassivate(HttpSessionEvent event)

{

if (synchronizationRegistered)

{

throw new IllegalStateException("cannot passivate persistence context with active transaction");

}

/**

* Note that we must use the method on the {@link HttpSessionActivationListener}

* interface rather than @PostActivate since interceptors are disabled

* on this component.

public void sessionDidActivate(HttpSessionEvent event) {}

@Destroy

public void destroy()

{

destroyed = true;

if ( !synchronizationRegistered )

{

//in requests that come through SeamPhaseListener,

//there can be multiple transactions per request,

//but they are all completed by the time contexts

//are destroyed

//so wait until the end of the request to close

//the session

//on the other hand, if we are still waiting for

//the transaction to commit, leave it open

close();

}

PersistenceContexts.instance().untouch(componentName);

}

public void afterCompletion(int status)

{

synchronizationRegistered = false;

//if ( !Contexts.isConversationContextActive() )

if (destroyed)

{

//in calls to MDBs and remote calls to SBs, the

//transaction doesn't commit until after contexts

//are destroyed, so wait until the transaction

//completes before closing the session

//on the other hand, if we still have an active

//conversation context, leave it open

close();

}

public void beforeCompletion() {}

private void close()

{

if (Contexts.isEventContextActive())

{

boolean transactionActive = false;

try

{

UserTransaction tx = Transaction.instance();

try

{

transactionActive = tx.isActive();

}

catch (SystemException se)

{

log.debug("could not get transaction status while destroying persistence context");

}

catch (Exception e)

{

// WebSphere throws a javax.naming.ConfigurationException when Transaction.instance() is called during HTTP Session expiration

// and there is no JNDI lookup possible. See details there: JBSEAM-4332

log.warn("could not get transaction while destroying persistence context. (called during session expiration ?)");

}

if ( transactionActive )

{

throw new IllegalStateException("attempting to destroy the persistence context while an active transaction exists (try installing <transaction:ejb-transaction/>)");

}

if ( log.isDebugEnabled() )

{

log.debug("destroying seam managed persistence context for persistence unit: " + persistenceUnitJndiName);

}

if (entityManager!=null && entityManager.isOpen())

{

entityManager.close();

}

public EntityManagerFactory getEntityManagerFactoryFromJndiOrValueBinding()

{

EntityManagerFactory result = null;

//first try to find it via the value binding

if (entityManagerFactory!=null)

{

result = entityManagerFactory.getValue();

}

//if its not there, try JNDI

if (result==null)

{

try

{

result = (EntityManagerFactory) Naming.getInitialContext().lookup(persistenceUnitJndiName);

}

catch (NamingException ne)

{

throw new IllegalArgumentException("EntityManagerFactory not found in JNDI : " + persistenceUnitJndiName, ne);

}

return result;

}

/**

* A value binding expression that returns an EntityManagerFactory,

* for use of JPA outside of Java EE 5 / Embeddable EJB3.

public ValueExpression<EntityManagerFactory> getEntityManagerFactory()

{

return entityManagerFactory;

}

public void setEntityManagerFactory(ValueExpression<EntityManagerFactory> entityManagerFactory)

{

this.entityManagerFactory = entityManagerFactory;

}

/**

* The JNDI name of the EntityManagerFactory, for

* use of JPA in Java EE 5 / Embeddable EJB3.

public String getPersistenceUnitJndiName()

{

return persistenceUnitJndiName;

}

public void setPersistenceUnitJndiName(String persistenceUnitName)

{

this.persistenceUnitJndiName = persistenceUnitName;

}

public String getComponentName()

{

return componentName;

}

/**

* Hibernate filters to enable automatically

public List<Filter> getFilters()

{

return filters;

}

public void setFilters(List<Filter> filters)

{

this.filters = filters;

}

public void changeFlushMode(FlushModeType flushMode)

{

if (entityManager!=null && entityManager.isOpen())

{

setEntityManagerFlushMode(flushMode);

}

protected void setEntityManagerFlushMode(FlushModeType flushMode)

{

switch (flushMode)

{

case AUTO:

entityManager.setFlushMode(javax.persistence.FlushModeType.AUTO);

break;

case COMMIT:

entityManager.setFlushMode(javax.persistence.FlushModeType.COMMIT);

break;

case MANUAL:

PersistenceProvider.instance().setFlushModeManual(entityManager);

break;

}

@Override

public String toString()

{

return "ManagedPersistenceContext(" + persistenceUnitJndiName + ")";

}

@Unwrap 으로 지정하고 … Continue reading →

Posted in Java, JBoss | コメントは受け付けていません。

15
8月

保護中: RsaShaSigner 를 이용한 서명

この投稿はパスワードで保護されているため抜粋文はありません。

Posted in Java, Security | コメントは受け付けていません。

8
8月

SAML Assertion의 XML서명검증

아래와 같은 SAML Response 를 응답받았다고 가정하고, 서명을 … Continue reading →

Posted in Java, Security | コメントは受け付けていません。

Monthly Archives: 8月 2013

HttpServletResponseWrapper 샘플

Seam에서 EntityManager 생성하는 녀석

保護中: RsaShaSigner 를 이용한 서명

SAML Assertion의 XML서명검증

最近の投稿

最近のコメント

アーカイブ

カテゴリー

メタ情報