membangun aplikasi client server "java"

membangun aplikasi client server "java"
Pertama kita lakukan pengetikan koding program di dalam notepad, editplus ataupun IDE lainnya sebagai berikut
Aplikasi Server
import java.io.*;
import java.net.*;

public class SimpleServer {
    public final static int TESTPORT = 5000;
    public static void main(String args[]) {
        ServerSocket checkServer = null;
        String line;
        BufferedReader is = null;
        DataOutputStream os = null;
        Socket clientSocket = null;
      
        try {
            checkServer = new ServerSocket(TESTPORT);
            System.out.println("Aplikasi Server hidup...");
        } catch (IOException e) {
            System.out.println(e);
        }
      
        try {
            clientSocket = checkServer.accept();
            is = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            os = new DataOutputStream(clientSocket.getOutputStream());
        } catch (Exception ei) {
            ei.printStackTrace();
        }
        try {
            line = is.readLine();
            System.out.println("Terima : " + line);
            if (line.compareTo("salam") == 0) {
                os.writeBytes("salam Juga");
            } else {
                os.writeBytes("Maaf, saya tidak mengerti");
            }
        } catch (IOException e) {
            System.out.println(e);
        }
      
        try {
            os.close();
            is.close();
            clientSocket.close();
        } catch (IOException ic) {
            ic.printStackTrace();
        }
    }

}
Aplikasi Client
import java.io.*;
import java.net.*;

public class SimpleClient {
    public final static int REMOTE_PORT = 5000;
    public static void main(String args[]) throws Exception {
        Socket cl = null;
        BufferedReader is = null;
        DataOutputStream os = null;
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
        String userInput = null;
        String output = null;
     
        //Membuka koneksi ke server pada port REMOTE-PORT
        try {
            cl = new Socket(args[0], REMOTE_PORT);
            is = new BufferedReader(new InputStreamReader(cl.getInputStream()));
            os = new DataOutputStream(cl.getOutputStream());
        } catch (UnknownHostException e1) {
            System.out.println("Unknown Host: " + e1);
        } catch (IOException e2) {
            System.out.println("Error io: " + e2);
        }
     
        //Menulis ke server
        try {
            System.out.println("Dari server: " + output);
            userInput = stdin.readLine();
            os.writeBytes(userInput + "\n");
        } catch (IOException ex) {
            System.out.println("Error writing to server..." + ex);
        }
     
        //Menerima tanggapan dari server
        try {
            output = is.readLine();
            System.out.println("Dari Server: " + output);
        } catch (IOException e) {
            e.printStackTrace();
        }
     
        //close input stream, output stream dan koneksi
        try {
            is.close();
            os.close();
            cl.close();
        } catch (IOException x) {
            System.out.println("Error writing..." + x); 
        }
    }
}

Setelah kita mengetikan koding tersebut, kita simpan dengan nama "SimpleServer.java" dan "SimpleClient.java" didalam direktori mana pun di komputer atau laptop kita, misalnya di "D:\workspace\ObtainIP\src". Setelah kita simpan, kita buka cmd atau Command Prompt sebanyak dua window yang nantinya akan kita pakai untuk COMPILE  "SimpleServer.java" dan "SimpleClient.java".Compile di cmd pertama kita lakukan untuk "SimpleServer.java". Ketik "javac SimpleServer.java" dalam cmd server lalu tekan Enter. Setelah itu kita ketik  "java SimpleServer" lalu tekan Enter. Maka aplikasi server sudah kita aktifkan. Setelah kita compile "SimpleServer.java", selanjutnya kita lakukan compile "SimpleClient.java". Ketik "javac SimpleClient.java" dalam cmd server lalu tekan Enter.
Setelah itu kita ketik  "java SimpleClient " lalu tekan Enter. Lalu kita coba ketikkan kata "salam" dan coba perhatikan apa yang terlihat didalam cmd server dan client. Kondisi yang ada antara kedua cmd tersebut adalah jika Client mengirimkan kata "salam" kepada Server, maka Server akan menerimanya dan membalas ke Client dengan kata "salam juga". Tetapi jika Client mengirimkan pesan yang tidak sesuai dengan kondisi diatas, maka Server akan mengirimkan pesan "Maaf, saya tidak mengerti" kepada client.

tugas besar client server "membuat game domino"

coding :

package game;

import game.exceptions.InvalidFaceValueException;
import game.exceptions.InvalidNumberOfPlayersException;
import game.exceptions.InvalidPieceToPlayException;
import game.exceptions.NotPlayersTurnException;

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

import server.Server;
import client.Client;
import client.ClientRemote;
import game.Board;
import game.Domino;

public class Game {
        public static final int NUMBER_OF_MESSAGES_PER_GAME = 3;
     
        public static final int NUMBER_OF_PLAYERS = 4; // numero de jogadores total por jogo. deve ser um múltiplo de 2
        private static final int CURR_PLAYER_UNDEFINED = -1;
     
        private List<Domino> dominoes;
        private List<Player> players; // jogadores do jogo
        private Board board; // mesa do jogo (situação atual das peças jogadas
        private int currentPlayer = CURR_PLAYER_UNDEFINED; // jogador atual
        private Domino firstPiece = null;

        private Server server;
             
        // Players can be added to the game all in one time by the Game object constructor
        public Game(List<Player> players, Server server) throws InvalidNumberOfPlayersException {
                this.server = server;
             
                if (players == null || players.size() != NUMBER_OF_PLAYERS) {
                        throw new InvalidNumberOfPlayersException();
                }
             
                List<Player> tempPlayers = new ArrayList<Player>();
                for (Player p: players) {
                        p.setCurrentGame(this);
                        tempPlayers.add(p);
                }
             
                // sorteando a ordem dos jogadores, o jogador de indice 0 será parceiro do jogador de indice 2, e o 1 do 3
                this.players = new ArrayList<Player>();
                for (int i = 0; i < NUMBER_OF_PLAYERS; i++) {
                        this.players.add(tempPlayers.remove((int) (Math.random() * (NUMBER_OF_PLAYERS - i))));
                }
             
                this.board = new Board();
        }
     
        public void startGame() throws RemoteException {              
                // Creating game pieces
                createDominoPieces();
             
                System.out.println("Existem " + players.size() + " Jogadores no jogo sendo iniciado.");
                             
                // ramdom dominoes to decide players pieces
                for (int i = 0; i < NUMBER_OF_PLAYERS; i++) {
                        List<Domino> pieces = new ArrayList<Domino>();
                     
                        for (int j = 0; j < 6; j++) {
                                int index = (int) (Math.random() * (28 - (i * 6 + j)));
                                pieces.add(dominoes.remove(index));                          
                        }
                        players.get(i).setPieces(pieces);
                }

                // decidindo quem sera o primeiro jogador (encontrar o dozão ou outra carroça)
                currentPlayer = CURR_PLAYER_UNDEFINED;
                int firstPiece = 6;
                this.firstPiece = null;
                do {
                        for (Player p: players) {
                                for (Domino d: p.getPieces()) {
                                        if (d.getFace1() == firstPiece && d.getFace2() == firstPiece) {
                                                currentPlayer = players.indexOf(p);
                                                this.firstPiece = d;
                                                break;
                                        }
                                }
                                if (currentPlayer != CURR_PLAYER_UNDEFINED) break; // já foi  encontrado o jogador que ira iniciar
                        }
                        firstPiece--; // procurar por uma carroça de menor valor
                } while (currentPlayer == CURR_PLAYER_UNDEFINED && firstPiece >= 0);
                if (currentPlayer == CURR_PLAYER_UNDEFINED) currentPlayer = 0;
             
                waitForPlayersToBeReady();
             
                // enviar uma mensagem a cada jogador, indicando que um jogo está sendo iniciado
                for (Player p: players) {
                        p.getStub().receiveMessage("Game", "O jogo está sendo iniciado.");
                }
             
                // setando os parceiros dos jogadores, e chamando o método remoto em cada jogador para iniciar o jogo
                List<String> playersNames = new ArrayList<String>();
                for (int i = 0; i < players.size(); i++) {
                        playersNames.add(players.get((currentPlayer + i) % NUMBER_OF_PLAYERS).getUserName());
                }
                if (NUMBER_OF_PLAYERS % 2 == 0) {
                        for (int i = 0; i < NUMBER_OF_PLAYERS / 2; i++) {
                                Player p = players.get(i);
                                p.setPartner(players.get(i + NUMBER_OF_PLAYERS / 2).getUserName());
                                p.getStub().startGame(playersNames, p.getPieces());
                             
                                p = players.get(i + NUMBER_OF_PLAYERS / 2);
                                p.setPartner(players.get(i).getUserName());
                                p.getStub().startGame(playersNames, p.getPieces());
                        }    
                }
             
                refreshPlayersTurns();
        }
     
        private void createDominoPieces() {
                dominoes = new ArrayList<Domino>();
                for (int i = 0; i <= 6; i++) {
                        for (int j = i; j <= 6; j++) {
                                try {
                                        dominoes.add(new Domino(i, j));
                                } catch (InvalidFaceValueException e) {
                                        e.printStackTrace();
                                }
                        }
                }
        }
     
        private void waitForPlayersToBeReady() throws RemoteException {
                for (Player p: players) {
                        String service = Client.SERVICE_NAME_PREFIX + p.getUserName();                
                        Registry registry = LocateRegistry.getRegistry();
                     
                        ClientRemote stub = null;
                        int i = 0;
                        do {
                                try {
                                        stub = (ClientRemote) registry.lookup(service);
                                        System.out.println("O Servico remoto do jogador " + p.getUserName() + " esta pronto.");
                                } catch (NotBoundException e) {
                                        System.out.println("O Jogador " + p.getUserName() + " ainda não inicializou o serviço remoto");
                                        try {
                                                Thread.sleep(500);
                                                i++;
                                        } catch (InterruptedException e1) {
                                                e1.printStackTrace();
                                        }
                                }    
                        } while (stub == null || i >= 20);
                     
                        if (i >= 20) removePlayer(p);
                     
                        p.setStub(stub);
                }
        }
     
        public void makeMove(Player p, Domino d, int position) throws NotPlayersTurnException, InvalidPieceToPlayException {
                if (players.get(currentPlayer).equals(p)) {
                        if (d != null) {
                                if (board.isAValidPieceToPlay(d, position)) {
                                        board.addPiece(d, position);
                                        players.get(currentPlayer).getPieces().remove(d);
                                        currentPlayer = (currentPlayer + 1) % NUMBER_OF_PLAYERS;
                                } else {
                                        throw new InvalidPieceToPlayException();
                                }
                        } else {
                                currentPlayer = (currentPlayer + 1) % NUMBER_OF_PLAYERS;
                        }
                             
                        for (Player player: players) {
                                if (!player.equals(p)) {
                                        try {
                                                player.getStub().moveMade(d, position);
                                        } catch (RemoteException e) {
                                                removePlayer(player);
                                                return;
                                        }
                                }
                        }
                     
                        // TODO verificar se o jogo terminou
                        if (p.getPieces().size() == 0) {
                                // o jogador bateu: finalizar o jogo
                                playerWon(p);
                                return;
                        } else {
                                boolean finalized = true;
                                for (Player pTemp: players) {
                                        for (Domino dTemp: pTemp.getPieces()) {
                                                if (board.isAValidPieceToPlay(dTemp, Board.POSITION_START) || board.isAValidPieceToPlay(dTemp, Board.POSITION_END)) {
                                                        finalized = false;
                                                        break;
                                                }
                                        }
                                        if (!finalized) break;
                                }
                                if (finalized) {
                                        countPiecesPoints();
                                        return;
                                }
                        }
                     
                        // iniciando em uma nova Thread para poder retornar sem ficar bloqueado
                        new Thread() {
                                public void run() {
                                        refreshPlayersTurns();                                        
                                }
                        }.start();
                     
                } else {
                        throw new NotPlayersTurnException();
                }
        }
     
        private void refreshPlayersTurns() {
                // chamando o método para que os jogadores iniciem as jogadas
                PlayerThread t = null;
                for (int i = 0; i < NUMBER_OF_PLAYERS; i++) {
                        if (i == currentPlayer) {
                                // iniciando uma nova thread, para que a atual (do jogo) não fique bloqueada
                                t = new PlayerThread(players.get(i)) {                                
                                        public void run() {
                                                try {
                                                        p.getStub().myTimeToPlay();
                                                } catch (RemoteException e) {
                                                        remoteExceptionThrowed = true;
                                                }    
                                        }
                                };
                                t.start();
                        } else {
                                try {
                                        players.get(i).getStub().waitAnotherPlayersMove();
                                } catch (RemoteException e) {
                                        removePlayer(players.get(i));
                                        return;
                                }
                        }
                }
             
                if (t != null) {
                        if (t.isRemoteExceptionThrowed()) {
                                removePlayer(players.get(currentPlayer));
                                return;
                        } else {
                                while (t.getState() != Thread.State.TERMINATED) {
                                        try {
                                                Thread.sleep(300);
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                        }
                }
        }
     
        // retorno o numero de caracteres máximo de uma mensagem, dada a quantidade de mensagens ainda disponíveis
        public static int getNumberOfCharsByAvailableMessages(int availableMessages) {
                int maximumNumberOfChars = 10;
             
                if (availableMessages <= NUMBER_OF_MESSAGES_PER_GAME && availableMessages >= 0) {
                        return maximumNumberOfChars - (NUMBER_OF_MESSAGES_PER_GAME - availableMessages) * 2;
                }
             
                return 0;
        }

        public boolean isAValidPieceToPlay(Domino d) {
                // verificando se a peça está com o jogador da vez
                for (Domino pd: players.get(currentPlayer).getPieces()) {
                        if (pd.equals(d)) {
                                // verificando se a peça pode ser jogada
                                if (board.getDominoes() == null || board.getDominoes().size() == 0) {
                                        if (firstPiece == null) {
                                                return true;
                                        } else {
                                                return firstPiece.equals(d);
                                        }
                                } else {
                                        boolean valid = board.isAValidPieceToPlay(d, Board.POSITION_START) || board.isAValidPieceToPlay(d, Board.POSITION_END);
                                        if (valid) return true;
                                        else return false;
                                }
                        }
                }
             
                return false;
        }

        public void removePlayer(final Player playerToRemove) {
                // os outros jogadores devem ser liberados para jogar
                for (Player player: players) {
                        if (playerToRemove != player) {
                                try {
                                        player.setCurrentGame(null);
                                     
                                        player.getStub().receiveMessage("Servidor", "O Jogador " + playerToRemove.getUserName() + " saiu do jogo. O jogo está sendo finalizado.");
                                        player.getStub().receiveMessage("Servidor", "Outro Jogo será iniciado assim que possível");
                                     
                                        PlayerThread pt = new PlayerThread(player) {
                                                public void run() {
                                                        try {
                                                                this.p.getStub().endGame(Client.END_GAME_CAUSE_PLAYER_LOGGED_OUT, "O Jogador " + playerToRemove.getUserName() + " saiu do jogo.\nO jogo está sendo finalizado.");
                                                                server.freePlayer(p);
                                                        } catch (RemoteException e) {
                                                                remoteExceptionThrowed = true;
                                                                Game.this.server.removePlayer(p);
                                                        }            
                                                }
                                        };
                                        pt.start();
                                } catch (RemoteException e) {
                                        this.server.removePlayer(playerToRemove);
                                }
                        }
                }
        }
     
        private void playerWon(final Player winner) {
                for (Player player: players) {
                        try {
                                player.setCurrentGame(null);
                             
                                if (player != winner) {
                                        player.getStub().receiveMessage("Servidor", "O Jogador " + player.getUserName() + " Bateu! Um Novo Jogo Será iniciado.");    
                                } else {
                                        player.getStub().receiveMessage("Servidor", "Você Venceu o Jogo!!! Um Novo Jogo Será iniciado.");
                                }
                             
                             
                                PlayerThread pt = new PlayerThread(player) {
                                        public void run() {
                                                try {
                                                        if (p != winner) {
                                                                this.p.getStub().endGame(Client.END_GAME_CAUSE_PLAYER_WON, "O Jogador " + winner.getUserName() + " Bateu!\nUm novo jogo será iniciado assim que possível.");  
                                                        } else {
                                                                this.p.getStub().endGame(Client.END_GAME_CAUSE_PLAYER_WON, "Você Venceu o Jogo!!!\nUm novo jogo será iniciado assim que possível.");
                                                        }                                                    
                                                        server.freePlayer(p);
                                                } catch (RemoteException e) {
                                                        remoteExceptionThrowed = true;
                                                        Game.this.server.removePlayer(p);
                                                }            
                                        }
                                };
                                pt.start();
                        } catch (RemoteException e) {
                                this.server.removePlayer(player);
                        }
                }
        }
     
     
        private void countPiecesPoints() {
                int less = -1;
                final List<Player> winners = new ArrayList<Player>();
             
                // contagem dos pontos
                for (Player p: players) {
                        if (less == -1 || p.getPoints() < less) {
                                winners.clear();
                                winners.add(p);
                                less = p.getPoints();
                        } else if (p.getPoints() == less) {
                                winners.add(p);
                        }
                }
             
                String w = "";
                for (Player p: winners) {
                        w += p.getUserName();
                        if (winners.indexOf(p) < winners.size() - 2) {
                                w += ", ";
                        } else if (winners.indexOf(p) == winners.size() - 2) {
                                w += " e ";
                        }
                }
             
                final String s = w;
             
                for (Player player: players) {
                        try {
                                player.setCurrentGame(null);
                             
                                if (winners.size() == 1) {
                                        if (!winners.contains(player)) {
                                                player.getStub().receiveMessage("Servidor", "O Jogador " + winners.get(0).getUserName() + " Venceu nos pontos! Um Novo Jogo Será iniciado.");
                                        } else {
                                                player.getStub().receiveMessage("Servidor", "Você Venceu o Jogo nos Pontos!!! Um Novo Jogo Será iniciado.");
                                        }
                                } else {
                                     
                                        player.getStub().receiveMessage("Servidor", "Empate entre os jogadores " + w + "! Um Novo Jogo Será iniciado.");      
                                     
                                }
                             
                                PlayerThread pt = new PlayerThread(player) {
                                        public void run() {
                                                try {
                                                        if (winners.size() == 1) {
                                                                if (!winners.contains(p)) {
                                                                        this.p.getStub().endGame(Client.END_GAME_CAUSE_GAME_CLOSED, "O Jogador " + winners.get(0).getUserName() + " Venceu nos Pontos!\nUm novo jogo será iniciado assim que possível.");    
                                                                } else {
                                                                        this.p.getStub().endGame(Client.END_GAME_CAUSE_GAME_CLOSED, "Você Venceu o Jogo nos Pontos!!!\nUm novo jogo será iniciado assim que possível.");
                                                                }
                                                        } else {
                                                                this.p.getStub().endGame(Client.END_GAME_CAUSE_GAME_CLOSED, "Empate entre os jogadores " + s + "!\nUm novo jogo será iniciado assim que possível.");
                                                        }
                                                        server.freePlayer(p);
                                                } catch (RemoteException e) {
                                                        remoteExceptionThrowed = true;
                                                        Game.this.server.removePlayer(p);
                                                }            
                                        }
                                };
                                pt.start();
                        } catch (RemoteException e) {
                                this.server.removePlayer(player);
                        }
                }
        }
}

Konfigurasi Jaringan Client Server

Konfigurasi Klien Jaringan Client Server
Untuk melakukan konfigurasi jaringan pada Windows XP, beberapa langkah yang dapat kamu lakukan diantaranya adalah setting kartu jaringan, konfigurasi TCP/IP, dan pemetaan drive jaringan.

Konfigurasi Jaringan Klien Windows XP
Langkah konfigurasi komputer klien Windows P pada jaringan Client Server adalah :

•     Pastikan kartu jaringan telah terinstal driver dengan benar, klik Start, Settings, Control Panel, dobel klik System. Pilih tabulasi Hardware, kemudian klik Device Manager.
•     Setelah kartu jaringan terinstal driver dengan benar, lakukan konfigurasi alamat IP, klik Start, Control Panel dan dobel klik Network Connections, dobel klik Local Area Connections. Atau, kamu dapat juga mengklik icon Local Area Connections pada taskbar.
•     Pada kotak dialog Local Area Connections Status, klik Properties sehingga akan ditampilkan kotak dialog Local Area Connection Properties. Pilih Internet Protocol (TCP/IP), kemudian klik Properties.
•     Pilih Use the following IP address dan masukkan IP Address dan Subnet mask-nya. Selanjutnya, masukkan alamat IP Addres Server, sebagai contoh, masukkan 192.168.0.2 dengan Subnet Mask 255.255.255.0. Setelah selesai memasukkan alamat IP, klik tombol OK.
•     Lakukan pengujian koneksi dari komputer klien dengan komputer server, buka jendela Command Prompt (DOS Prompt). Ketik ping <nama komputer/IP Address>. Pastikan pesan yang ditampilkan Reply from 192.168.0.1, yang berarti komputer klien telah terhubung dengan komputer server.

Menghubungkan dengan Komputer Server
Langkah menghubungkan komputer klien Windows XP dengan komputer server adalah :

1. Klik Start, Setting, Control Panel, dobel klik System, pilih tabulasi Computer Name dan klik Change.
2. Pada kotak dialog Computer Name Change, pilih Domain di bagian Member Of. Kemudian masukkan nama domain server pada kotak isiannya. klik OK untuk mengakhiri.
3. Masukkan User Name dan Password untuk dapat bergabung dengna domain. Masukkan user Administrator atau yang setingkat dari Windows 2003 Server, beserta passwordnya. Klik OK.
4. Tunggu prosesnya beberapa saat hingga ditampilkan pesan terhubung dengan domain. Klik OK untuk menyetujuinya.
5. Sistem akan meminta boot ulang, setelah komputer melakukan boot ulang maka akan ditampilkan kotak dialog Welcome to Windows, dan tekan Ctrl+Alt+Delete secara bersamaan.
6. Setelah itu akan ditampilkan pengisian user name dan password, masukkan User name dan Password pada kotak yang telah disediakan.

KONFIGURASI DHCP SERVER DAN SETING PADA KOMPUTER CLIENT

KONFIGURASI DHCP SERVER DAN SETTING PADA KOMPUTER KLIEN

Dengan Dynamic Host Configuration Protokol (DHCP) membuat administrasi jaringan TCP/IP menjadi lebih mudah.Pada server DHCP kita tidak perlu membberikanalamt IP secara manual pada setiap nnode (workstation), karena server DHCP akan memberikan alamat ip secara dinamis pada komputerworkstation tersebut . Batas alamat IPyang diberikan untuk node (workstation ) cukup di setting dari address pool pada Mikrotik OS DHCP Server. Ada 2 jenis DHCPdalam system jaringan yaitu :

DHCP Server

DHCP yang akan memberikan alamat ip ke work station.

DHCP client

DHCP yang akan menerima alamat IP yang diberikan oleh DHCP server

Sebelum melakukan settingmikrotik os sebagai DHCP Server internet, pastikan option DHCP telah diaktifkan (dipilih)saat menginstal mikrotik OS . Untuk membuat DHCP Server diperlukan langkah – langkah sebagi berikut:

a. Mmbuat address pool dan menentukan IP Range

b. Mengaktifkan DHCPServer.

c. Setting InternetGateway Server.

Konfigurasi dengan winbox :

1. Instalasi interface

Klik menu interface –>nameàGeneral–>Apply–>OK

 

2. Setting IP address
Klik menu IPàAddressàtanda+ warna merahàApply–>OK

 

3. Konfigurasi IP gateway
Klik menu IP routeàtanda+ warna merah –>Apply–>OK

 

4.KOnfigurasi IP DNS
KlikmenuIP –>DNSàSettings–>Apply–> OK

 

5. Setting Address pool

Klik menu IPàpoolàpoolsàKlik tanda+warna merah–>Apply –>Ok

 

6. Klik menuIP–>DHCP Server–>Networksàtanda+awrna merah–>Apply–>OK

 

 

 7. Menentukan interface lan DHcp Dan mengaktifkan dhcp server
Klik menu IP–>DHCP Server–>DHCPàtanda + warna merah–>Apply–>Ok

 

8. setting IP firewall nat
Klik menu IP–>firewallàNAT–>tanda + warna merah–>Apply–>OK

 

SETTING PADA KOMPUTER CLIENT
9.Klik Start –>Control PanelàNetwork ConnectionsàLocal Area ConnectionàPropertiesàInternet Protokol(TCP/IP)àIPaddress automatically–>OK