new ImageFrame(inImg, "Input Image ");// inImg is reference to Image object
The code below can be used to load images in JFrame as a separate window.
Showing posts with label java. Show all posts
Showing posts with label java. Show all posts
Java: Loading images in JFrame - Reusable ImageFrame
Sometimes we need to show multiple images in separate window by using single line statement :
java copy file, move file code example
Java source code - copying a file , moving a file - working source code example :
Code for deleting a folder and sub folder recursively is here
Code for deleting a folder and sub folder recursively is here
public final class FileIOUtility {
private FileIOUtility() {}
public static void moveFile(File src, File targetDirectory) throws IOException {
if (!src.renameTo(new File(targetDirectory, src.getName()))) {
String str = (new StringBuilder()).append("Failed to move ").append(src).append(" to ").append(targetDirectory).toString();
throw new IOException(str);
} else
Tutorial on Ibatis-Using Eclipse Ibator plugin to generate Persistence POJO Models, SqlMap and DAO :: with coverage of Dynamic SQL and working downloadable example
IBatis is a lightweight persistence framework that maps objects to SQL statements. The SQL is decoupled from the application logic by storing in XML descriptor file . SQL mapping is done by data mapper to persist objects to a relational database.
In this article i am going to discuss on how to use ibator plugin in eclipse to generate Java model objects from your database, the DAO interface and its auto implementation to access your db and auto generated SQL map xml files. And also we will deal with fun of dynamic SQL. The Link for downloading the working eclipse project is given at the end of article. For more detail about ibatis visit the references at last of this article.
Part A: Ibator/DB Configuration
In this article i am going to discuss on how to use ibator plugin in eclipse to generate Java model objects from your database, the DAO interface and its auto implementation to access your db and auto generated SQL map xml files. And also we will deal with fun of dynamic SQL. The Link for downloading the working eclipse project is given at the end of article. For more detail about ibatis visit the references at last of this article.
Part A: Ibator/DB Configuration
Step 1. Installing IBator
Visit this link and download ibator plugin for eclipse
http://code.google.com/p/mybatis/wiki/Downloads?tm=2
Or From Eclipse Update Site :
http://ibatis.apache.org/tools/ibator
http://code.google.com/p/mybatis/wiki/Downloads?tm=2
Or From Eclipse Update Site :
http://ibatis.apache.org/tools/ibator
Step 2. Requirements and Project Configuration:
EasyJFrame : Reusable JFrame class
Here, i am going to describe a reusable jFrame class, which can be used as substitute of standard console output.
Resuable JFrame CODE:
Resuable JFrame CODE:
Java-Opening a URL in default browser with start utility in windows
Java-Opening a URL in default browser with start utility in windows
String cmd = "cmd.exe /c start ";
String file = "http://www.google.com";
Runtime.getRuntime().exec(cmd + file);
Dependency Injection with Java Spring IoC, A Complete Example
Here i am going to describe a simple
example of Dependency Injection which uses Spring IoC framework.
You may refer to my earlier"Understanding Dependency Injection and Its
Importance" for understanding the concepts.
This example uses Implementation of
Operation, Reader and Writer Interfaces.
We simply perform a one of the
arithmentic Operation by taking values from Reader and write the values using
Writer Class.
Reader Interface:
public interface Reader {
Operands readValues(String promptMsg);
}
Its implementations can be:
ConsoleReader:
public class
ConsoleReader implements Reader{
Operands oprnds;
Scanner sc;
public ConsoleReader (){
oprnds=new Operands();
sc=new Scanner(System.in);
}
public Operands readValues(String promptMsg) {
System.out.println(promptMsg);
oprnds.setOp1(sc.nextLong());
oprnds.setOp2(sc.nextLong());
return oprnds;
}
}
The Operation Interface
public interface Operation {
Result operate(long op1,long op2);
String getOperationName();
}
The Operation Interface can have
implementations such as
Multiply
public class Multiply implements Operation {
Result res;
public Multiply(){
res=new Result();
}
public Result operate(long op1, long op2) {
res.setRes(op1*op2);
return res;
}
public String getOperationName() {
return "Multiply";
}
}
Addition
public class Add implements Operation {
Result res;
public Add(){
res=new Result();
}
public Result operate(long op1, long op2) {
res.setRes(op1+op2);
return res;
}
public String getOperationName() {
return "Add";
}
}
The writer Interface
public interface Writer {
void write(Result res);
}
Its ConsoleWriter Implementation
public class
ConsoleWriter implements Writer{
public void write(Result
res) {
System.out.println("The result after
operation : "+res.getRes());
}
}
Its TXTFileWriter Implementation
public class
TXTFileWriter implements Writer{
File file;
PrintWriter fwriter;
public TXTFileWriter(){
try {
file = new File("output.txt");
fwriter = new PrintWriter(
new BufferedWriter( new FileWriter(file)));
} catch (Exception ex) {
System.err.println(ex);
}
}
public void write(Result
res)
{
fwriter.println(res.getRes());
fwriter.close();
}
}
The Model Classes
Operands
public class Operands {
private long op1;
private long op2;
//setters and
getters
}
The Result Class
public class Result {
private long res;
//setters and getters
}
Now create a configuration file in
class path i.e, src folder of project directory - confBean.xml.
<?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-2.0.xsd">
<bean id="operation"
class="com.gt.spring.operation.Add"/>
<bean id="reader" class="com.gt.spring.reader.ConsoleReader"/>
<bean id="writer"
class="com.gt.spring.writer.ConsoleWriter"/>
<beans>
The dependency injection will help
you to inject the implementations of an object at runtime.
In the Main Class: read the xml file
and inject the dependent beans…
public class Main {
public static void
main(String[] args) {
ApplicationContext ctx =
new
ClassPathXmlApplicationContext("confBean.xml");
//get beans from ctx
Reader rdr = (Reader) ctx.getBean("reader");
Operation opr = (Operation)ctx.getBean("operation");
Writer wrt = (Writer) ctx.getBean("writer");//
//read operands
Operands opnds = rdr.readValues("Enter
the Values :");
//do operation
Result res =opr.operate(opnds.getOp1(), opnds.getOp2());
//write result
wrt.write(res);
}
}
Dependency Injection in Java without Spring IoC Framework........ How it is possible... A Simple way
You can first read Understanding Dependency Injection and its Importance, before this post for clearing Funda of Dependency Injection.
How can we this do programmatically.
rotate();
applyBreak();
}
//override and define
}
class NepaleseRubberWheel implements Wheel{
//override and define
}
// Create Wheel object
Wheel wheelToRun =(Wheel) (Class.forName(wheelToInject).newInstance());
// Execute methods of the wheel object.
wheelToRun.rotate();
wheelToRun.applyBreak();
This works for any implementation of Wheel. To change the Wheel on the Car just change name of Implementation on the txt file.
How can we this do programmatically.
- Create a interface Wheel.
rotate();
applyBreak();
}
- Create implementations
//override and define
}
class NepaleseRubberWheel implements Wheel{
//override and define
}
- Create a txt file, where you write the valid name(say NepaleseRubberWheel ) of a Implementation of Wheel
- Read the txt file
- And finally, to Dynamically load the NepaleseRubberWheel as instance of Wheel;
// Create Wheel object
Wheel wheelToRun =(Wheel) (Class.forName(wheelToInject).newInstance());
// Execute methods of the wheel object.
wheelToRun.rotate();
wheelToRun.applyBreak();
This works for any implementation of Wheel. To change the Wheel on the Car just change name of Implementation on the txt file.
Understanding Dependency Injection and its Importance, A tutorial
Understanding Dependency Injection and its Importance
Any application is composed of many objects that collaborate with each other to perform some useful stuff. Traditionally each object is responsible for obtaining its own references to the dependent objects (dependencies) it collaborate with. This leads to highly coupled classes and hard-to-test code.For example, consider a `Car` object.
A `Car` depends on wheels, engine, fuel, battery, etc. to run. Traditionally we define the brand of such dependent objects along with the definition of the `Car` object.
Without Dependency Injection (DI):
class Car{
private Wheel wh = new NepaliRubberWheel();
private Battery bt = new ExcideBattery();
//The rest
}
Here, the `Car` object *is responsible for creating the dependent objects.*
What if we want to change the type of its dependent object - say `Wheel` - after the initial `NepaliRubberWheel()` punctures?
We need to recreate the Car object with its new dependency say `ChineseRubberWheel()`, but only the `Car` manufacturer can do that.
Then what does the `Dependency Injection` do for us...?
When using dependency injection, objects are given their dependencies *at run time rather than compile time (car manufacturing time)*.
So that we can now change the `Wheel` whenever we want. Here, the `dependency` (`wheel`) can be injected into `Car` at run time.
After using dependency injection:
Here, we are **injecting** the **dependencies** (Wheel and Battery) at runtime. Hence the term : *Dependency Injection.* We normally rely on DI frameworks such as Spring, Guice, Weld to create the dependencies and inject where needed. class Car{
private Wheel wh; // Inject an Instance of Wheel (dependency of car) at runtime
private Battery bt; // Inject an Instance of Battery (dependency of car) at runtime
Car(Wheel wh,Battery bt) {
this.wh = wh;
this.bt = bt;
}
//Or we can have setters
void setWheel(Wheel wh) {
this.wh = wh;
}
}
The advantages/benefits of dependency injection are:
- decoupling the creation of an object (in another word, separate usage from the creation of object)
- ability to replace dependencies (eg: Wheel, Battery) without changing the class that uses it(Car)
- promotes "Code to interface not to an implementation" principle
- ability to create and use mock dependency during a test (if we want to use a Mock of Wheel during test instead of a real instance.. we can create Mock Wheel object and let DI framework inject to Car)
Subscribe to:
Posts
(
Atom
)