org.omg.CORBA.OBJECT_NOT_EXIST. Eventually, I ended up trying to do a manual deploy using the ANT task wldeploy, with the following command ant -lib /apps/wls12130/wlserver/server/lib deploy -Dweblogic.user=adminuser -Dweblogic.password=adminpassword -Dadminurl=t3://admin-server:admin-port -Dweblogic.cluster=ClusterName[wldeploy] Caused by: javax.naming.NamingException: Couldn't connect to the specified host [Root exception is org.omg.CORBA.OBJECT_NOT_EXIST: Unknown object in LOCATE_REQUEST vmcid: 0x0 minor code: 0 completed: No] error. Following is the full stacktrace, followed by a cause and resolution to this problem...
private keyword.private method has to be implemented in the interface as it cannot implemented in a sub-interface or implementing classes.ZoneId zoneId = ZoneId.of("America/Chicago");Set zoneIdList = ZoneId.getAvailableZoneIds(); ZonedDateTime zonedDateTime = ZonedDateTime.of(localDateTime, zoneId);
ZonedDateTime.parse("2015-05-03T10:15:30+01:00[America/Los_Angeles]");truncateTo() method can be used to truncate the time fields. Any Time Unit lesser than the passed parameter will be marked to zero.// Anything under days is set to zero. Works only for time.
System.out.println(zonedDateTime + " Truncated to " + zonedDateTime.truncatedTo(ChronoUnit.HOURS));// Convert Time Zone
System.out.println(zonedDateTime + " in Los Angeles " + zonedDateTime.withZoneSameInstant(ZoneId.of("America/Los_Angeles")));System.out.println("3 days before today is : " + zonedDateTime.minus(3, ChronoUnit.DAYS));
System.out.println("3 decades before today is : " + zonedDateTime.minus(3, ChronoUnit.DECADES));
System.out.println("3 days after today is : " + zonedDateTime.plus(3, ChronoUnit.DAYS));
System.out.println("3 decades after today is : " + zonedDateTime.plus(3, ChronoUnit.DECADES));
System.out.println("The day of the week is : " + zonedDateTime.getDayOfWeek());
System.out.println("The day of the year is : " + zonedDateTime.getDayOfYear());// Now
OffsetDateTime offsetDateTime = OffsetDateTime.now();
System.out.println("OffsetDateTime : " + offsetDateTime);
// Get LocalDateTime and apply Offset
LocalDateTime localDateTime = LocalDateTime.of(2017, Month.SEPTEMBER, 29, 5, 30);
ZoneOffset offset = ZoneOffset.of("+02:00");
OffsetDateTime offSetByTwo = OffsetDateTime.of(localDateTime, offset);
System.out.println(localDateTime + " Offset by two " + offSetByTwo);
import java.time.LocalDateTime;
import java.time.Month;
import java.time.OffsetDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
public class ZonedDateTimeExamples {
public static void main(String[] args) {
ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("America/Chicago"));
System.out.println(zonedDateTime);
// Convert Time Zone
System.out
.println(zonedDateTime + " in Los Angeles " + zonedDateTime.withZoneSameInstant(ZoneId.of("America/Los_Angeles")));
// Anything under days is set to zero. Works only for time.
System.out.println(zonedDateTime + " Truncated to " + zonedDateTime.truncatedTo(ChronoUnit.HOURS));
System.out.println("3 days before today is : " + zonedDateTime.minus(3, ChronoUnit.DAYS));
System.out.println("3 decades before today is : " + zonedDateTime.minus(3, ChronoUnit.DECADES));
System.out.println("3 days after today is : " + zonedDateTime.plus(3, ChronoUnit.DAYS));
System.out.println("3 decades after today is : " + zonedDateTime.plus(3, ChronoUnit.DECADES));
System.out.println("The day of the week is : " + zonedDateTime.getDayOfWeek());
System.out.println("The day of the year is : " + zonedDateTime.getDayOfYear());
// Now
OffsetDateTime offsetDateTime = OffsetDateTime.now();
System.out.println("OffsetDateTime : " + offsetDateTime);
// Get LocalDateTime and apply Offset
LocalDateTime localDateTime = LocalDateTime.of(2017, Month.SEPTEMBER, 29, 5, 30);
ZoneOffset offset = ZoneOffset.of("+02:00");
OffsetDateTime offSetByTwo = OffsetDateTime.of(localDateTime, offset);
System.out.println(localDateTime + " Offset by two " + offSetByTwo);
}
}iterate() and ofNullable() methods.
Comparator.comparingDouble, Comparator.comparingInt and Comparator.comparingLong etc. methods can be used to do sorting or finding max and min from stream. The following example uses the comparingDouble method to compare and sort a stream of doubles generated using the Stream.generate() method. The Stream.generate has been explained my earlier post "Java 8 Streams" // Sort a stream of Doubles
Stream.generate(Math::random).limit(10).sorted(Comparator.comparingDouble(Double::valueOf)).forEach(System.out::println);InputStreams in a List as input and merged file is written to the file system.
java.nio.file.WatchService provides a scalable solution to monitor directory for any changes. In this post, we will go over the features of the WatchService service and a simple example for how to monitor a directory for changes and print the name of the file that was affected.
Files.walk() and Files.find() introduced in Java 8, which makes directory traversal even more simple.collect() method is a terminal operation, which can be used collect elements of a stream into a list or group them into a Map etc. collect method takes java.util.stream.Collector as parameter. While you can create your own collector by implementing the java.util.stream.Collector interface, the more common way to instantiate a Collector is through the use of Collectors class. The following examples demonstrate a few ways to use the collect() method with different types of Collectors.
flatMap() method is an intermediate functions for streams, in that, it will produce a final result but used to apply transformations on the elements of a Stream. It is possible to to chain multiple flatMap() while processing a single stream.
Both map() and flatMap() both can be applied to a Stream<T> and return a Stream<R> or transformed elements, but the main difference is that map() produces one output element for each input element, whereas flatMap() produces any number (0-n) of output elements for each input element. Put simply, when using a map(), the resulting stream would have same number or elements as the input stream, where as it can be different in case of a flatMap(). The following example illustrates the differences the use of flatMap()
java.util.stream.Stream Interface. Both methods are intermediate functions for streams, in that, they do not produce a final result but are used to apply transformations on the elements of a Stream. It is possible to to chain multiple map() and flatMap() while processing a single stream. int sum = widgets.stream() // Source
.filter(w -> w.getColor() == RED) // Intermediate operation
.mapToInt(w -> w.getWeight()) //Intermediate operation
.sum(); // Terminal operation, produces resultSqlSessionFactory from Spring. Instead of configuring the datasource and mapping in mybatis-config.xml, all configuration will be setup in Spring configuration. The only additional configuration will be the Mapper.xml file.This post is a continuation of the Spring Standalone Application post. In this post I will go over the application setup and the Gradle build file used for building the project. The assumption here is that Gradle is already installed on the machine and ready to use. For instructions on how to install Gradle please go the Gradle installation page.
Continue to full post ...Following is the directory structure I had for this project. In case of the Annotation based approach, you don't need the resources folder.
+---SpringStandalone
| build.gradle
|
\---src
+---main
| \---java
| +---main
| | SpringStandaloneTest.java
| |
| \---service
| TestService.java
| \---resources
| applicationContext.xml
|
\---test
\---javaThe Gradle Application plugin is very useful for creating Standalone applications that can be run using gradle run. By default, the Gradle Application plugin applies the java plugin and Distribution plugin. You can configure the main class and any JVM arguments that you may want to pass to the application.
To pass the main class name, you can use the mainClassName parameter like below
mainClassName = "main.SpringStandaloneTest"applicationDefaultJvmArgs as shown belowapplicationDefaultJvmArgs = ["-Dprop=val"]apply plugin:'application'
mainClassName = "main.SpringStandaloneTest"
applicationName = 'SpringStandalone'
repositories {
jcenter()
}
dependencies {
compile group: 'org.springframework', name: 'spring-core', version: '4.3.9.RELEASE'
compile group: 'org.springframework', name: 'spring-context', version: '4.3.9.RELEASE'
compile group: 'org.springframework', name: 'spring-beans', version: '4.3.9.RELEASE'
compile group: 'org.springframework', name: 'spring-tx', version: '4.3.9.RELEASE'
compile group: 'org.springframework', name: 'spring-orm', version: '4.3.9.RELEASE'
// Use JUnit test framework
compile 'junit:junit:4.12'
}
applicationDefaultJvmArgs = ["-Dprop=val"]Having a basic spring standalone application ready always helps when you want to do a quick POC or test of new libraries or tools you plan to use. This post shows a couple of ways in which you can setup a basic Spring standalone application.
For this application I will use a simple service class TestService that has a single method echo(), which returns the Upper case version of any string passed as a parameter. The TestService class will be used a component to be injected into the main application class.
In this model we have 4 files
package main;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.TestService;
public class SpringStandaloneTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
SpringStandaloneTest test = ctx.getBean("springStandalone", SpringStandaloneTest.class);
test.callService();
}
private TestService testService = null;
private void callService() {
System.out.println(testService.echo("Hello"));
}
public TestService getTestService() {
return testService;
}
public void setTestService(TestService testService) {
this.testService = testService;
}
}package service;
public class TestService {
public String echo(String str) {
return str.toUpperCase();
}
}<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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.xsd">
<bean name="testService" class="service.TestService" />
<bean name="springStandalone" class="main.SpringStandaloneTest">
<property name="testService" ref="testService"></property>
</bean>
</beans>In this model, we will setup the standalone application with annotations instead of the applicationContext.xml file. The annotation @Component is used to define a class as a Spring component, so that Spring can detect it as a Spring bean. The @ComponentScan is used to direct Spring where to look for Components. It is similar to the
package main;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import service.TestService;
@ComponentScan(basePackages= {"main", "service"})
public class SpringStandaloneTest {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(SpringStandaloneTest.class);
SpringStandaloneTest test = context.getBean(SpringStandaloneTest.class);
test.callService();
}
@Autowired
private TestService service = null;
private void callService() {
System.out.println(service .echo("Hello"));
}
}package service;
import org.springframework.stereotype.Component;
@Component
public class TestService {
public String echo(String str) {
return str.toUpperCase();
}
}Java 7 AsynchronousFileChannel is an asynchronous channel for reading and writing to files asynchronously. In this post, we will look into a few operations on AsynchronousFileChannel.
An AsynchronousFileChannel can be created using the open method. This static method takes the Path and the type of operations (READ, WRITE etc.) as paramters
Following is the read() method that returns a Future.
Future operation = fileChannel.read(buffer, 0); ByteBuffer parameter starting at the beginning of the file. Since this is an asynchronous call, the read() method will return immediately, even if the read is not completed. To check if the read wheter the read operation completed, you can call the isDone() on the returned Future object.package nio;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
public class AsyncFileChannelTest {
public static void main(String[] args) {
Path path = Paths.get("C:/test/data.csv");
AsynchronousFileChannel fileChannel = null;
try {
fileChannel = AsynchronousFileChannel.open(path, StandardOpenOption.READ);
ByteBuffer buffer = ByteBuffer.allocate(1024);
long position = 0;
StringBuffer fileData = new StringBuffer();
Future operation = fileChannel.read(buffer, position);
// Future returns -1 if End of File is reached.
while (operation.get() > 0) {
while (!operation.isDone())
;
// Switch ByteBuffer from read to write mode
buffer.flip();
byte[] data = new byte[buffer.limit()];
buffer.get(data);
fileData.append(new String(data));
buffer.clear();
// Update to new read position.
position = position + operation.get();
operation = fileChannel.read(buffer, position);
}
System.out.println(fileData);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
} This version of the read() operation takes a CompletionHandler as a parameter.
package nio;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
public class AsyncFileChannelTest {
public static class MyCompletionHandler
implements CompletionHandler {
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
// TODO Auto-generated method stub
}
@Override
public void completed(Integer result, ByteBuffer buffer) {
System.out.println("result = " + result);
bytesRead = result.intValue();
if (bytesRead < 0)
return;
// Switch ByteBuffer from read to write mode
buffer.flip();
byte[] data = new byte[buffer.limit()];
buffer.get(data);
fileData.append(new String(data));
buffer.clear();
position = position + bytesRead;
fileChannel.read(buffer, position, buffer, this);
}
}
private static int bytesRead = 0;
private static StringBuffer fileData = new StringBuffer();
private static long position = 0;
private static AsynchronousFileChannel fileChannel = null;
public static void main(String[] args) {
Path path = Paths.get("C:/test/data.csv");
try {
fileChannel = AsynchronousFileChannel.open(path, StandardOpenOption.READ);
ByteBuffer buffer = ByteBuffer.allocate(1024);
MyCompletionHandler myCompletionHandler = new MyCompletionHandler();
fileChannel.read(buffer, position, buffer, myCompletionHandler);
// read() returns -1 if End of File is reached.
while (bytesRead > 0) {
// Update to new read position.
position = position + bytesRead;
fileChannel.read(buffer, position, buffer, myCompletionHandler);
}
// Main thread waits till the asynchronous operations are complete
try {
Thread.currentThread().sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(fileData);
} catch (IOException e) {
e.printStackTrace();
}
}
} completed() method of CompletionHandler is called with the number of Bytes read as a paramter. The second parameter can be any object, and in our case, I passed the same ByteBuffer object as a parameter to help read the entire file. The failed() method is called if the read operation fails.
Writing to a file with Future follows the same model as read. The differnces are that you open the channel in "WRITE" mode instead of "READ" and call the write() method. When the write is done, the number bytes written to the file will be set in the Future. As with read() we wait till the read is complete by calling isDone() method.
package nio;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
public class AsyncFileChannelTest {
public static void main(String[] args) {
Path path = Paths.get("C:/test/data.csv");
AsynchronousFileChannel fileChannel = null;
try {
fileChannel = AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);
ByteBuffer buffer = ByteBuffer.allocate(100);
buffer.put("Hello World".getBytes());
buffer.flip();
Future operation = fileChannel.write(buffer, 0);
buffer.clear();
while(!operation.isDone());
System.out.println("Number of Bytes Written : " + operation.get());
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
} Writing to a file with CompletionHandler follows the same model as a read. The differnces are that you open the channel in "WRITE" mode instead of "READ" and call the write() method.
package nio;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
public class AsyncFileChannelTest {
public static class MyCompletionHandler implements CompletionHandler {
@Override
public void completed(Integer result, ByteBuffer attachment) {
System.out.println("Number of bytes written : " + result);
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
// TODO Auto-generated method stub
}
}
public static void main(String[] args) {
Path path = Paths.get("C:/test/data.csv");
AsynchronousFileChannel fileChannel = null;
try {
fileChannel = AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);
ByteBuffer buffer = ByteBuffer.allocate(100);
MyCompletionHandler myCompletionHandler = new MyCompletionHandler();
buffer.put("Hello World".getBytes());
buffer.flip();
fileChannel.write(buffer, 0, buffer, myCompletionHandler);
} catch (IOException e) {
e.printStackTrace();
}
// Main thread waits till the asynchronous operations are complete
try {
Thread.currentThread().sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}