package org.kodejava.swing;
import javax.swing.*;
import java.awt.*;
public class WindowTaskbarFlash extends JFrame {
private WindowTaskbarFlash() throws HeadlessException {
initUI();
}
public static void main(String[] args) {
SwingUtilities.invokeLater(
() -> new WindowTaskbarFlash().setVisible(true));
}
private void initUI() {
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
pack();
setSize(200, 200);
setState(Frame.ICONIFIED);
// Demonstrate flashes the application window task bar
// by calling the toFront method every 5 seconds.
Timer timer = new Timer(5000, e -> toFront());
timer.start();
}
}
Author: Wayan
How do I change JFrame state programmatically?
In the following code snippet you’ll learn how to programmatically change the frame state of a JFrame component in a Swing application. The JFrame states are represented as a bitwise masks. You can minimize, maximize or make the JFrame state to normal, using the JFrame.setExtendedState() method.
You can pass the following values as the parameter to the method:
Frame.NORMALFrame.ICONIFIEDFrame.MAXIMIZED_HORIZFrame.MAXIMIZED_VERTFrame.MAXIMIZED_BOTH
package org.kodejava.swing;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionListener;
public class SwingFrameState extends JFrame {
public SwingFrameState() throws HeadlessException {
initUI();
}
public static void main(String[] args) {
SwingUtilities.invokeLater(
() -> new SwingFrameState().setVisible(true));
}
private void initUI() {
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
setLayout(new FlowLayout());
final JButton minimize = new JButton("Minimize");
final JButton maximize = new JButton("Maximize");
final JButton normal = new JButton("Normal");
add(normal);
add(minimize);
add(maximize);
pack();
setSize(500, 200);
ActionListener listener = e -> {
if (e.getSource() == normal) {
setExtendedState(Frame.NORMAL);
} else if (e.getSource() == minimize) {
setExtendedState(Frame.ICONIFIED);
} else if (e.getSource() == maximize) {
setExtendedState(Frame.MAXIMIZED_BOTH);
}
};
minimize.addActionListener(listener);
maximize.addActionListener(listener);
normal.addActionListener(listener);
}
}
The screenshot of the output from the code snippet above is:
Change JFrame State Programmatically
How do I obtain ServletContext of another application?
The ServletContext.getContext(String uripath) enable us to access servlet context of another web application deployed on the same application server. A configuration need to be added to enable this feature.
In the example below we will forward the request from the current application to the /otherapp/hello.jsp page. We place a string in the request object attribute of the current application and going to show it in the hello.jsp page.
package org.kodejava.servlet;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
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 java.io.IOException;
@WebServlet(urlPatterns = {"/context"})
public class GetAnotherContextServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Get ServletContext of another application on the same Servlet
// container. This allows us to forward request to another application
// on the same application server.
ServletContext ctx = request.getServletContext().getContext("/otherapp");
// Set a request attribute and forward to hello.jsp page on another
// context.
request.setAttribute("MESSAGE", "Hello There!");
RequestDispatcher dispatcher = ctx.getRequestDispatcher("/hello.jsp");
dispatcher.forward(request, response);
}
}
To enable this feature in Tomcat we need to enable the crossContext attribute by setting the value to true, the default value is false. Update the server.xml file to add the following configuration inside the <Host> node.
<Context path="/webapp" debug="0" reloadable="true" crossContext="true"/>
Maven dependencies
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
How do I unpack an ISO 8583 message?
The code snippet below will show you how to unpack ISO 8583 message.
package org.kodejava.jpos;
import org.jpos.iso.ISOException;
import org.jpos.iso.ISOMsg;
import org.jpos.iso.packager.GenericPackager;
import java.io.InputStream;
public class UnpackISOMessage {
public static void main(String[] args) {
UnpackISOMessage iso = new UnpackISOMessage();
try {
ISOMsg isoMsg = iso.parseISOMessage();
iso.printISOMessage(isoMsg);
} catch (Exception e) {
e.printStackTrace();
}
}
private ISOMsg parseISOMessage() throws Exception {
String message = "02003220000000808000000010000000001500120604120000000112340001840";
System.out.printf("Message = %s%n", message);
try {
// Load package from resources directory.
InputStream is = getClass().getResourceAsStream("/fields.xml");
GenericPackager packager = new GenericPackager(is);
ISOMsg isoMsg = new ISOMsg();
isoMsg.setPackager(packager);
isoMsg.unpack(message.getBytes());
return isoMsg;
} catch (ISOException e) {
throw new Exception(e);
}
}
private void printISOMessage(ISOMsg isoMsg) {
try {
System.out.printf("MTI = %s%n", isoMsg.getMTI());
for (int i = 1; i <= isoMsg.getMaxField(); i++) {
if (isoMsg.hasField(i)) {
System.out.printf("Field (%s) = %s%n", i, isoMsg.getString(i));
}
}
} catch (ISOException e) {
e.printStackTrace();
}
}
}
When you run the program you’ll get the following output:
Message = 02003220000000808000000010000000001500120604120000000112340001840
MTI = 0200
Field (3) = 000010
Field (4) = 000000001500
Field (7) = 1206041200
Field (11) = 000001
Field (41) = 12340001
Field (49) = 840
The xml packager (fields.xml) can be downloaded from the following link: fields.xml.
Maven Dependency
<dependency>
<groupId>org.jpos</groupId>
<artifactId>jpos</artifactId>
<version>2.1.8</version>
</dependency>
How do I pack an ISO 8583 message?
The code snippet below show you how to pack an ISO 8583 message.
package org.kodejava.jpos;
import org.jpos.iso.ISOException;
import org.jpos.iso.ISOMsg;
import org.jpos.iso.packager.GenericPackager;
import java.io.InputStream;
public class PackISOMessage {
public static void main(String[] args) {
PackISOMessage iso = new PackISOMessage();
try {
String message = iso.buildISOMessage();
System.out.printf("Message = %s", message);
} catch (Exception e) {
e.printStackTrace();
}
}
private String buildISOMessage() throws Exception {
try {
// Load package from resources directory.
InputStream is = getClass().getResourceAsStream("/fields.xml");
GenericPackager packager = new GenericPackager(is);
ISOMsg isoMsg = new ISOMsg();
isoMsg.setPackager(packager);
isoMsg.setMTI("0200");
isoMsg.set(3, "000010");
isoMsg.set(4, "1500");
isoMsg.set(7, "1206041200");
isoMsg.set(11, "000001");
isoMsg.set(41, "12340001");
isoMsg.set(49, "840");
printISOMessage(isoMsg);
byte[] result = isoMsg.pack();
return new String(result);
} catch (ISOException e) {
throw new Exception(e);
}
}
private void printISOMessage(ISOMsg isoMsg) {
try {
System.out.printf("MTI = %s%n", isoMsg.getMTI());
for (int i = 1; i <= isoMsg.getMaxField(); i++) {
if (isoMsg.hasField(i)) {
System.out.printf("Field (%s) = %s%n", i, isoMsg.getString(i));
}
}
} catch (ISOException e) {
e.printStackTrace();
}
}
}
When you run the program you’ll get the following output:
MTI = 0200
Field (3) = 000010
Field (4) = 1500
Field (7) = 1206041200
Field (11) = 000001
Field (41) = 12340001
Field (49) = 840
Message = 02003220000000808000000010000000001500120604120000000112340001840
The xml packager (fields.xml) can be downloaded from the following link: fields.xml.
Maven Dependency
<dependency>
<groupId>org.jpos</groupId>
<artifactId>jpos</artifactId>
<version>2.1.8</version>
</dependency>