Distributed programming with RMI

package model;

import java.io.Serializable;

public class Customer implements Serializable{
	private static final long serialVersionUID = 20210811004L;
	private int id;
	private String name;
	private String idCard;
	private String address;
	private String tel;
	private String email;
	private String note;
	
	public Customer() {
		super();
	}
	
	public Customer(String name, String idCard, String address, String tel, String email, String note) {
		super();
		this.name = name;
		this.idCard = idCard;
		this.address = address;
		this.tel = tel;
		this.email = email;
		this.note = note;
	}

	public int getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

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

	public String getIdCard() {
		return idCard;
	}

	public void setIdCard(String idCard) {
		this.idCard = idCard;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public String getTel() {
		return tel;
	}

	public void setTel(String tel) {
		this.tel = tel;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getNote() {
		return note;
	}

	public void setNote(String note) {
		this.note = note;
	}
}

import java.io.Serializable;
 public class User implements Serializable{
     private String userName;
     private String password;
     public User(){        
     }
     public User(String username, String password){
         this.userName = username;
         this.password = password;
     }
     public String getPassword() {
         return password;
     }
     public void setPassword(String password) {
         this.password = password;
     }
     public String getUserName() {
         return userName;
     }
     public void setUserName(String userName) {
         this.userName = userName;
     }
 }

package rmi.general;

import java.rmi.Remote;
import java.rmi.RemoteException;
import java.util.ArrayList;

import model.Customer;

public interface CustomerInterface extends Remote{
	public ArrayList<Customer> searchCustomer(String key) throws RemoteException;
	public boolean editCustomer(Customer cus) throws RemoteException;
}

package rmi.server;
 import java.rmi.Remote;
 import java.rmi.RemoteException;
 import rmi.server.User;
 public interface RMILoginInterface extends Remote{
     public String checkLogin(User user) throws RemoteException;
 }

package jdbc.dao;

import java.sql.Connection;
import java.sql.DriverManager;

public class DAO {
	public static Connection con;
	
	public DAO(){
		if(con == null){
			String dbUrl = "jdbc:mysql://localhost:3307/hotel?autoReconnect=true&useSSL=false";
			String dbClass = "com.mysql.jdbc.Driver";

			try {
				Class.forName(dbClass);
				con = DriverManager.getConnection (dbUrl, "root", "xxx");
			}catch(Exception e) {
				e.printStackTrace();
			}
		}
	}
}

 package jdbc.dao;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.Types;
import java.util.ArrayList;

import model.Customer;

public class CustomerDAO extends DAO{
	
	/**
	 * search all clients in the tblClient whose name contains the @key
	 * using PreparedStatement - recommended for professional coding
	 * @param key
	 * @return list of client whose name contains the @key
	 */
	public ArrayList<Customer> searchCustomer(String key){
		ArrayList<Customer> result = new ArrayList<Customer>();
		String sql = "SELECT * FROM tblclient WHERE name LIKE ?";
		try{
			PreparedStatement ps = con.prepareStatement(sql);
			ps.setString(1, "%" + key + "%");
			ResultSet rs = ps.executeQuery();

			while(rs.next()){
				Customer client = new Customer();
				client.setId(rs.getInt("id"));
				client.setName(rs.getString("name"));
				client.setIdCard(rs.getString("idcard"));
				client.setAddress(rs.getString("address"));
				client.setTel(rs.getString("tel"));
				client.setEmail(rs.getString("email"));
				client.setNote(rs.getString("note"));
				result.add(client);
			}
		}catch(Exception e){
			e.printStackTrace();
		}	
		return result;
	}
	
	/**
	 * update the @client
	 * @param client
	 */
	public boolean editCustomer(Customer client){
		String sql = "UPDATE tblclient SET name=?, idcard =?, address=?, tel=?, email=?, note=? WHERE id=?";
		try{
			PreparedStatement ps = con.prepareStatement(sql);
			ps.setString(1, client.getName());
			ps.setString(2, client.getIdCard());
			ps.setString(3, client.getAddress());
			ps.setString(4, client.getTel());
			ps.setString(5, client.getEmail());
			ps.setString(6, client.getNote());
			ps.setInt(7, client.getId());

			ps.executeUpdate();
		}catch(Exception e){
			e.printStackTrace();
			return false;
		}
		return true;
	}
	
}

package rmi.server.control;


import java.net.InetAddress;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.ExportException;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;

import jdbc.dao.CustomerDAO;
import jdbc.dao.UserDAO;
import model.Customer;
import model.IPAddress;
import model.User;
import rmi.general.CustomerInterface;
import rmi.general.UserInterface;
import rmi.server.view.ServerMainFrm;


public class ServerCtr extends UnicastRemoteObject implements CustomerInterface{
	private IPAddress myAddress = new IPAddress("localhost", 9999); 	// default server host/port
	private Registry registry;
	private ServerMainFrm view;
	private String rmiService = "rmiServer"; 	// default rmi service key
	
	public ServerCtr(ServerMainFrm view) throws RemoteException{
		this.view = view;	
	}
	
	public ServerCtr(ServerMainFrm view, int port, String service) throws RemoteException{
		this.view = view;	
		myAddress.setPort(port);
		this.rmiService = service;
	}
	
	public void start() throws RemoteException{
		// registry this to the localhost
		try{
			try {
				//create new one
				registry = LocateRegistry.createRegistry(myAddress.getPort());
			}catch(ExportException e) {//the Registry exists, get it
				registry = LocateRegistry.getRegistry(myAddress.getPort());
			}
			registry.rebind(rmiService, this);
			myAddress.setHost(InetAddress.getLocalHost().getHostAddress());
			view.showServerInfo(myAddress, rmiService);
			view.showMessage("The RIM has registered the service key: " + rmiService + ", at the port: " + myAddress.getPort());
		}catch(RemoteException e){
			throw e;
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	public void stop() throws RemoteException{
		// unbind the service
		try{
			if(registry != null) {
				registry.unbind(rmiService);
				UnicastRemoteObject.unexportObject(this,true);
			}
			view.showMessage("The RIM has unbinded the service key: " + rmiService + ", at the port: " + myAddress.getPort());
		}catch(RemoteException e){
			throw e;
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	
	@Override
	public ArrayList<Customer> searchCustomer(String key) throws RemoteException {
		return new CustomerDAO().searchCustomer(key);
	}

	@Override
	public boolean editCustomer(Customer cus) throws RemoteException {
		return new CustomerDAO().editCustomer(cus);
	}
}

package rmi.server.view;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

import model.IPAddress;
import rmi.server.control.ServerCtr;

public class ServerMainFrm extends JFrame implements ActionListener{
	private JTextField txtServerHost, txtServerPort, txtServerService;
	private JButton btnStartServer, btnStopServer;	
	private JTextArea mainText;
	private ServerCtr myServer;
	
	public ServerMainFrm(){
		super("RMI server view");		
		
		JPanel mainPanel = new JPanel();
		mainPanel.setLayout(null);
		
		JLabel lblTitle = new JLabel("Server RMI");
		lblTitle.setFont(new java.awt.Font("Dialog", 1, 20));
		lblTitle.setBounds(new Rectangle(150, 15, 200, 30));
		mainPanel.add(lblTitle, null);
		
		JLabel lblHost = new JLabel("Server host:");
		lblHost.setBounds(new Rectangle(10, 70, 150, 25));
		mainPanel.add(lblHost, null);
		
		txtServerHost = new JTextField(50);
		txtServerHost.setBounds(new Rectangle(170, 70, 150, 25));
		txtServerHost.setText("localhost");
		txtServerHost.setEditable(false);
		mainPanel.add(txtServerHost,null);
		
		JLabel lblPort = new JLabel("Server port:");
		lblPort.setBounds(new Rectangle(10, 100, 150, 25));
		mainPanel.add(lblPort, null);
		
		txtServerPort = new JTextField(50);
		txtServerPort.setBounds(new Rectangle(170, 100, 150, 25));
		mainPanel.add(txtServerPort,null);
		
		JLabel lblService = new JLabel("Service key:");
		lblService.setBounds(new Rectangle(10, 150, 150, 25));
		mainPanel.add(lblService, null);
		
		txtServerService = new JTextField(50);
		txtServerService.setBounds(new Rectangle(170, 150, 150, 25));
		mainPanel.add(txtServerService,null);
		
		btnStartServer = new JButton("Start server");
		btnStartServer.setBounds(new Rectangle(10, 200, 150, 25));
		btnStartServer.addActionListener(this);
		mainPanel.add(btnStartServer,null);
		
		btnStopServer = new JButton("Stop server");
		btnStopServer.setBounds(new Rectangle(170, 200, 150, 25));
		btnStopServer.addActionListener(this);
		btnStopServer.setEnabled(false);
		mainPanel.add(btnStopServer,null);
		
		  		
		JScrollPane jScrollPane1 = new JScrollPane();
		mainText = new JTextArea("");
		jScrollPane1.setBounds(new Rectangle(10, 250, 610, 240));
		mainPanel.add(jScrollPane1, BorderLayout.CENTER);
		jScrollPane1.getViewport().add(mainText, null);
		
		this.setContentPane(mainPanel);
		this.pack();	
		this.setSize(new Dimension(640, 480));
		this.setResizable(false);
		this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);		
		this.addWindowListener( new WindowAdapter(){
		   public void windowClosing(WindowEvent e) {
			   if(myServer != null)
				   try {
					   myServer.stop();
				   }catch(Exception ex) {
					   ex.printStackTrace();
				   }
		     System.exit(0);
		     }
		  });
	}

	public void showServerInfo(IPAddress serverAddr, String service) {
		txtServerHost.setText(serverAddr.getHost());
		txtServerPort.setText(serverAddr.getPort()+"");
		txtServerService.setText(service);
	}
	
	@Override
	public void actionPerformed(ActionEvent ae) {
		// TODO Auto-generated method stub
		if(ae.getSource() instanceof JButton) {
			JButton clicked = (JButton)ae.getSource();
			if(clicked.equals(btnStartServer)) {// start button
				try{
					if(!txtServerPort.getText().isEmpty() && (txtServerPort.getText().trim().length() > 0) &&
							!txtServerService.getText().isEmpty() && (txtServerService.getText().trim().length() > 0)) {//custom port
						int port = Integer.parseInt(txtServerPort.getText().trim());
						myServer = new ServerCtr(this, port, txtServerService.getText().trim());
					}else {// default port
						myServer = new ServerCtr(this);
					}
					myServer.start();
					btnStopServer.setEnabled(true);
					btnStartServer.setEnabled(false);
				}catch(Exception e) {
					mainText.append("\n Error in starting the RIM server");
					e.printStackTrace();
				}
			}else if(clicked.equals(btnStopServer)) {// stop button
				if(myServer != null) {
					try {
						myServer.stop();
						myServer = null;
					}catch(Exception e) {
						mainText.append("\n Error in closing the RIM server");
						e.printStackTrace();
					}
				}				
				btnStopServer.setEnabled(false);
				btnStartServer.setEnabled(true);
				txtServerHost.setText("localhost");
			}
		}
	}
	
	public void showMessage(String s){
		  mainText.append("\n"+s);
		  mainText.setCaretPosition(mainText.getDocument().getLength());
	}
	
	public static void main(String[] args) {
		ServerMainFrm view = new ServerMainFrm();
		view.setVisible(true);
	}
}

package rmi.client.control;

import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.ArrayList;

import model.Customer;
import model.IPAddress;
import model.User;
import rmi.client.view.ClientMainFrm;
import rmi.general.CustomerInterface;
import rmi.general.UserInterface;


public class ClientCtr {
	private ClientMainFrm view;
	private CustomerInterface customerRO;
	private IPAddress serverAddress = new IPAddress("localhost", 9999); //default server address
	private String rmiService = "rmiServer";							//default server service key
	
	public ClientCtr(ClientMainFrm view){
		this.view = view;
	}
		
	public ClientCtr(ClientMainFrm view, String serverHost, int serverPort, String service){
		this.view = view;
		serverAddress.setHost(serverHost);
		serverAddress.setPort(serverPort);
		rmiService = service;
	}	
	
	public boolean init(){
		try{
			// get the registry
			Registry registry = LocateRegistry.getRegistry(serverAddress.getHost(), serverAddress.getPort());
			// lookup the remote objects
			customerRO = (CustomerInterface)(registry.lookup(rmiService));
			
			view.setServerHost(serverAddress.getHost(), serverAddress.getPort()+"", rmiService);
			view.showMessage("Found the remote objects at the host: " + serverAddress.getHost() + ", port: " + serverAddress.getPort());
		}catch(Exception e){
			e.printStackTrace();
			view.showMessage("Error to lookup the remote objects!");
			return false;
		}
		return true;
	}
		
	public ArrayList<Customer> remoteSearchCustomer(String key){
		try {
			return customerRO.searchCustomer(key);
		}catch(RemoteException e) {
			e.printStackTrace();
			return null;
		}
	}
	
	public String remoteEditCustomer(Customer cus) {
		try {
			if(customerRO.editCustomer(cus))
				return "ok";
			else
				return "failed";
		}catch(RemoteException e) {
			e.printStackTrace();
			return null;
		}
	}
}