www.fatihkabakci.com

Personal Website and Computer Science TUR EN

JMS(JAVA MESAJLASMA SERVISI)

Last update: 6/28/2015 3:15:00 PM

Yazan:Fatih KABAKCI

Bileşen yönelimli paradigmanın çok eskiden beri eseri olan JMS mimarisi, bileşenler arasında haberleşme sağlayan bir standart olarak bilinir. JMS(Java Messaging Service - Java Mesajlaşma Servisi), özellikle J2EE uygulamalarında, web ve business katmanındaki bileşenler arasında kullanılan bir teknolojidir. JMS uygulamaları JMS API ile sağlanır ve sorumluluk application server da, yani uygulama sunucusunun kendisindedir.

JMS iki haberleşme mimarisini kullanır.

- point to point(noktadan noktaya)
- publisher/subscriber(yayıncı/abone).

Bu yazıda her iki uygulamaya da yer verilmiştir. İlk örnekte bir Queue nesnesi üzerinden mesajlaşma sağlanırken, ikinci örnekte kullanılan nesne Topic nesnesidir. Topic nesnesinin Queue ' dan farkı, mesajları alırken başlıklarına göre alabilmesidir. JMS bu iki nesneyi argüman olarak kullanarak uç birimler oluşturur. Aşağıda her iki mimariyi kullanan JMS örneklerini inceleyim.

Not: Bu örnekte Tomcat sunucusu kullanılmıştır. Kullanılan JMS sağlayıcı ise ActiveMQ dır. JMS sağlayıcının Tomcat' e tanıtımı bir sonraki ayrımda açıklanmaktadır.

JMS Provider

JMS mesajlarını alıp vermede yönetimi sağlayan yapılar JMS sağlayıcılardır. Bu yazıda örnek sağlayıcı ActiveMQ teknolojisidir. Bu sebepten ötürü activemq-all-5.4.0.jar ve commons-logging-1.1.jar dosyalarına ihtiyacınız bulunmaktadır. Bu jarları Google üzerinden temin edebilirsiniz.

JMS Konfigürasyonu

JMS mesajlaşmasını gerçekleyebilmek için, JMS sağlayıcısını sunucu üzerinde tanıtmak gerekmektedir. Bunun için aşağıda sırayla anlatılan adımları uygulayın.

1. activemq-all-5.4.0.jar ve commons-logging-1.1.jar dosyalarını Tomcat' in kurulu olduğu dizinde \lib folder' ı içerisine yerleştirin. Şayet sisteminizde Tomcat sunucusu yok ise öncelikle Apache Tomcat adlı yazıdan yararlanabilirsiniz.

2. Tomcat' in kurulu olduğu dizinde bulunan \conf\server.xml dosyasına aşağıdaki kaynakları tanıtın.

<GlobalNamingResources>
              
    <Resource name="jms/ConnectionFactory" auth="Container" type="org.apache.activemq.ActiveMQConnectionFactory" 
    description="JMS" connection="" factory="org.apache.activemq.jndi.JNDIReferenceFactory" 
    brokerurl="tcp://localhost:61616¨" brokername="ActiveMQBroker" useembeddedbroker="false" />
  
    <Resource name="jms/topic/MyTopic" auth="Container" type="org.apache.activemq.command.ActiveMQTopic" 
     factory="org.apache.activemq.jndi.JNDIReferenceFactory" physicalname="APP.JMS.TOPIC" />  
  
    <Resource name="jms/queue/MyQueue" auth="Container" type="org.apache.activemq.command.ActiveMQQueue" 
     factory="org.apache.activemq.jndi.JNDIReferenceFactory" physicalname="" app.jms.queue="" />

</GlobalNamingResources>

3. Yine Tomcat' in kurulu olduğu dizinde bulunan \conf\context.xml dosyası içerisine, kaynaklara bağlantı yapan ifadeleri tanıtın.

<Context>    
    <ResourceLink global="jms/ConnectionFactory" name="jms/ConnectionFactory" type="javax.jms.ConnectionFactory" />
    <ResourceLink global="jms/topic/MyTopic" name="jms/topic/MyTopic" type="javax.jms.Topic" />
    <ResourceLink global="jms/queue/MyQueue" name="jms/queue/MyQueue" type="javax.jms.Queue" />
</Context>

4. Son olarak Tomcat' in kurulu olduğu dizinde bulunan \conf\catalina.properties dosyasına aşağıdaki JMS sağlayıcının özelliklerini ekleyin.

#JMS configuration
JAVA_OPTS=-Dwebconsole.type=properties -Dwebconsole.jms.url=tcp://localhost:61616 -Dwebconsole.jmx.url=service:jmx:rmi:///jndi/rmi://localhost:1099/jmxrmi

Bu noktada yukarıdaki adımların uygulanması ile ActiveMQ JMS sağlayıcısı Tomcat üzerinde tanıtılmış olacaktır. Bir sonraki ayrımda BasicJMS adlı dinamik web projesi Eclipse içerisinde oluşturulmuştur. Queue ve Topic paketleri ile hem noktadan noktaya, hem de yayıncı/abone örneklerine yer verilmiştir.

Eclipse BasicJMS Project

JMS Queue

JMS mesalarının noktadan noktaya haberleşmesinde kullanılan yapı Queue nesnesidir. Gönderici, bir mesaj gönderdiği zaman, bu mesajı JMS sağlayıcı alır ve kuyruğa ekler. Alıcı taraf ne zaman mesajı almak isterse, JMS sağlayıcı o zaman mesajı alıcıya gönderir ve kuyruktan bu mesajı çıkarır. JMS mesajlaşmasında tarafların senkronize olma zorunluluğu yoktur.

Aşağıda Queue modelini kullanan JMS sender sınıfı verilmektedir.

JMSSender Sınıfı
package com.fatihkabakci.Queue;
import javax.jms.JMSException;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

/**
 * This class is JMS sender client. JMSSender sends a message using a JMS queue;
 * 
 * @author www.fatihkabakci.com
 */
public class JMSSender {
   QueueConnection connection;
   QueueSession    session;
   QueueSender     sender;

   String          connectionFactoryName;
   String          queueName;

   public JMSSender(String connectionFactoryName, String queueName) {
      this.connectionFactoryName = connectionFactoryName;
      this.queueName = queueName;
   }

   /**
    * 
    * @param text
    */
   public void send(String text) {
      try {
         InitialContext initContext = new InitialContext();
         // get the environment context
         Context context = (Context) initContext.lookup("java:comp/env");
         // create connection factory
         QueueConnectionFactory connectionFactory = (QueueConnectionFactory) context.lookup(connectionFactoryName);
         // create connection
         connection = connectionFactory.createQueueConnection();
         // create session
         session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
         // create queue
         Queue queue = session.createQueue(queueName);
         // create sender
         sender = session.createSender(queue);
         // create message
         TextMessage msg = session.createTextMessage();
         // fill message
         msg.setText(text);
         // send message
         sender.send(msg);
      }
      catch (JMSException e) {
         e.printStackTrace();
      }
      catch (NamingException e) {
         e.printStackTrace();
      }
   }

   /**
    * 
    * @throws JMSException
    */
   public void disconnect() throws JMSException {
      sender.close();
      session.close();
      connection.close();
   }
}

JMSSender sınıfı 6 temel elementi oluşturarak mesajını kuyruğa gönderir. Bu elementler;

ConnectionFactory
Connection
Session
Queue
Sender
Message

yukarıda listelenmiştir. ConnectionFactory Connection oluşturmak için kullanılır. Bir Connection QueueConnection ya da TopicConnection olabilir. Oluşturulan Connection ile kuyruğun oturumundan sorumlu bir Session yaratılır. Bir Session QueueSession veya TopicSession olabilir. Yukarıdaki Session argümanlarından ilki, oturumun transaction yapısına ait olup olmadığını belirtir. false ile bu oturumun bir transaction yapısında çalışmayacağı belirtilir. Bunun anlamı mesajların commit ve rollback yapıları ile çalışmayacağı anlamına gelir. Session ' ın ikinci argümanı olan Session.AUTO_ACKNOWLEDGE ise JMS sağlayıcının mesajı karşı tarafa gönderdiğinde göndericiye bunu haber vermesini bildirir. Oturum oluşturulduktan sonra, mevcut oturumdan bir kuyruk oluşturulur. Bu kuyruk mesajları muhafaza eden bellek olarak düşünebilir. Sender oluşturulurken daha önce oluşturulan kuyruğa göre yaratılır. Çünkü gönderici mesajlarını Queue' ya gönderecektir. En sonunda bir Message oluşturularak gönderilir. Mesajların farklı tipleri bulunmaktadır. Bu örnekte düz metinsel mesaj formatı olan TextMessage nesnesi kullanılmıştır.

Aşağıda noktadan noktaya mimarinin diğer uç birimi olan alıcının nasıl bir mesajı kuyruktan aldığını gösteren JMSReceiver sınıfı verilmektedir.

JMSReceiver Sınıfı
package com.fatihkabakci.Queue;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueReceiver;
import javax.jms.QueueSession;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnectionFactory;

/**
 * This class is JMS receiver client. JMSReceiver gets a message using a JMS queue;
 * 
 * @author www.fatihkabakci.com
 */
public class JMSReceiver {
   private QueueConnection connection;
   private QueueSession    session;
   private QueueReceiver   receiver;
   private String          queueName;
   private String          url;

   /**
    * @param url
    * @param queueName
    */
   public JMSReceiver(String url, String queueName) {
      this.url = url;
      this.queueName = queueName;
   }

   /**
    * @param timeout
    * @return
    * @throws JMSException
    */
   public Message receive(long timeout) throws JMSException {
      ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
      connection = (QueueConnection) connectionFactory.createQueueConnection();
      connection.start();

      session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
      Queue queue = session.createQueue(queueName);
      receiver = session.createReceiver(queue);

      Message message = receiver.receive(timeout);
      return message;
   }

   /**
    * @throws JMSException
    */
   public void disconnect() throws JMSException {
      receiver.close();
      session.close();
      connection.close();
   }
}

Point to point alıcıları, mesajları almak için sürekli JMS' e bağlı olma zorunluluğu gerekmez. Bir mesajı almak isteyen bir alıcı, ilgili kuyruğu oluşturarak mesajı oradan alır. Yukarıdaki örnekte mesaj belirtilen mili saniye cinsinden, timeout süresi kadar bekler. Bu süre içerisinde mesajı almaya niyetlenir. Şayet bu süre zarfında mesajı alamaz ise, receive() metodu null döner.

JMS Topic

JMS mesajlarının publisher/subscriber (yayıncı/abone) mimarisi için kullandığı yapı Topic nesnesidir. Bir topic mesajların başlığına göre alınmasını sağlar. Bu modelde bir gönderici bir den fazla alıcı bulunabilir. Şayet alıcılar mesajı dinlemeye başlarlar ise, mesaj bitimine kadar mesajı dinlemek zorundadırlar. Bu örnekte basitlik açısından 1 gönderici 1 alıcı kullanılmıştır. Ancak birden fazla alıcı pek tabi ki kullanılabilir.

JMSPublisher Sınıfı
package com.fatihkabakci.Topic;

import javax.jms.JMSException;
import javax.jms.Topic;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicPublisher;
import javax.jms.TopicSession;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

/**
 * This class is JMS publisher client. JMSSender publishes a message using a JMS topic;
 * 
 * @author www.fatihkabakci.com
 */
public class JMSPublisher {
   TopicConnection connection;
   TopicSession    session;
   TopicPublisher  publisher;

   String          connectionFactoryName;
   String          topicName;

   public JMSPublisher(String connectionFactoryName, String topicName) {
      this.connectionFactoryName = connectionFactoryName;
      this.topicName = topicName;
   }

   /**
    * @param text
    */
   public void publish(String text) {
      try {
         InitialContext initContext = new InitialContext();
         // get the environment context
         Context context = (Context) initContext.lookup("java:comp/env");
         // create connection factory
         TopicConnectionFactory connectionFactory = (TopicConnectionFactory) context.lookup(connectionFactoryName);
         // create connection
         connection = connectionFactory.createTopicConnection();
         // create session
         session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
         // create queue
         Topic topic = session.createTopic(topicName);
         // create sender
         publisher = session.createPublisher(topic);
         // create message
         TextMessage msg = session.createTextMessage();
         // fill message
         msg.setText(text);
         // send message
         publisher.publish(msg);
      }
      catch (JMSException e) {
         e.printStackTrace();
      }
      catch (NamingException e) {
         e.printStackTrace();
      }
   }

   /**
    * @throws JMSException
    */
   public void disconnect() throws JMSException {
      publisher.close();
      session.close();
      connection.close();
   }
}

JMSPublisher sınıfı 6 temel elementi oluşturarak mesajını topice gönderir. Bu elementler;

ConnectionFactory
Connection
Session
Topic
Publisher
Message

yukarıda listelenmiştir. Yukarıdaki JMSPublisher sınıfının publish() metodunun işleyişi yapısı açısından JMSSender sınıfının send() metodu ile aynıdır.

JMSSubscriber Sınıfı
package com.fatihkabakci.Topic;

import javax.jms.JMSException;
import javax.jms.Topic;
import javax.jms.TopicConnection;
import javax.jms.TopicSession;
import javax.jms.Session;
import javax.jms.TopicSubscriber;

import org.apache.activemq.ActiveMQConnectionFactory;

/**
 * This class is JMS subscriber client. JMSSubscriber listens a message using a JMS topic;
 * 
 * @author www.fatihkabakci.com
 */
public class JMSSubscriber {
   private TopicConnection connection;
   private TopicSession    session;
   private TopicSubscriber subscriber;
   private String          topicName;
   private String          url;

   public String getTextFromListener() {
      return TextListener.text;
   }

   /**
    * @param url
    * @param queueName
    */
   public JMSSubscriber(String url, String topicName) {
      this.url = url;
      this.topicName = topicName;
   }

   /**
    * @param timeout
    * @return
    * @throws JMSException
    */
   public void receive() throws JMSException {
      ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
      connection = (TopicConnection) connectionFactory.createTopicConnection();

      session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
      Topic topic = session.createTopic(topicName);
      subscriber = session.createSubscriber(topic);

      TextListener tl = new TextListener();
      subscriber.setMessageListener(tl);
      connection.start();
   }

   /**
    * @throws JMSException
    */
   public void disconnect() throws JMSException {
      subscriber.close();
      session.close();
      connection.close();
   }
}

Bir JMS abonesi(subscriber), mesajı alırken point to point mimariden farklı olarak dinleyiciler(listeners) yardımıyla bu mesajı alabilir. Yukarıdaki örnekte metin mesajlarını dinlemek için yaratılan bir TextListener örneği kullanılmıştır. Bu nesne örneği aboneye bağlanarak, mesajları dinleyebilmesini sağlar. Aşağıda da TextListener sınıfının nasıl oluşturulduğu gösterilmektedir.

TextListener Sınıfı
package com.fatihkabakci.Topic;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

/**
 * This class implements MessageListener and catches incoming messages to subscriber.
 * 
 * @author www.fatihkabakci.com
 */
public class TextListener implements MessageListener {

   public static String text = null;

   @Override
   public void onMessage(Message message) {
      if (message instanceof TextMessage) {
         TextMessage textMessage = (TextMessage) message;
         try {
            text = textMessage.getText();
         }
         catch (JMSException e) {
            e.printStackTrace();
         }
      }
   }
}

TextListener MessageListener sınıfının onMessage() metodunu override ederek gelen mesajları dinler. Burada basit bir String ile mesajlar alınır. Bunun sebebi, tüm mesajlaşma yapısını bir Servlet üzerinden takip etmek amacıdır. Bir sonraki ayrımda kullanılan Servlet sınıfı verilmektedir.

JMSServlet Sınıfı

package com.fatihkabakci;

import java.io.IOException;
import java.io.PrintWriter;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.TextMessage;
import javax.servlet.ServletConfig;
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 org.apache.activemq.broker.BrokerService;

import com.fatihkabakci.Queue.JMSReceiver;
import com.fatihkabakci.Queue.JMSSender;
import com.fatihkabakci.Topic.JMSPublisher;
import com.fatihkabakci.Topic.JMSSubscriber;

/**
 * Servlet implementation class JMSServlet
 * 
 * @author www.fatihkabakci.com
 */
@WebServlet("/JMSServlet")
public class JMSServlet extends HttpServlet {
   private static final long  serialVersionUID   = 1L;

   private BrokerService      broker;
   public final static String URL                = "tcp://localhost:61616";
   public final static String CONNECTION_FACTORY = "jms/ConnectionFactory";
   public final static String QUEUE              = "jms/queue/MyQueue";
   public final static String TOPIC              = "jms/topic/MyTopic";

   /**
    * @see HttpServlet#init(ServletConfig config)
    */
   public void init(ServletConfig config) throws ServletException {
      try {
         broker = new BrokerService();
         broker.addConnector("tcp://localhost:61616");
         broker.start();
      }
      catch (Exception e) {
         e.printStackTrace();
      }
   }

   /**
    * @see HttpServlet#service(HttpServletRequest request, HttpServletResponse response)
    */
   protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      try {

         PrintWriter out = response.getWriter();
         response.setContentType("text/html");
         boolean isQueueMessaging = (request.getParameter("queue") == null) ? false : true;

         if (isQueueMessaging) {
            boolean isReceive = (request.getParameter("breceive") == null) ? false : true;
            if (isReceive) {
               JMSReceiver receiver = new JMSReceiver(URL, QUEUE);
               Message message = receiver.receive(5);
               String text = getText(message);
               out.println("<h2>Message Received:" + text + "</h2>");
               receiver.disconnect();
            }
            else {
               String textMessage = request.getParameter("qmessage");
               if (textMessage != null) {
                  JMSSender sender = new JMSSender(CONNECTION_FACTORY, QUEUE);
                  sender.send(textMessage);
                  sender.disconnect();
                  out.println("<h2>Message sent !</h2>");
               }
            }
         }
         // topic messaging
         else {
            boolean isSubscribe = (request.getParameter("bsubscribe") == null) ? false : true;
            if (isSubscribe) {
               JMSSubscriber subscriber = new JMSSubscriber(URL, TOPIC);
               subscriber.receive();
               String text = null;
               while ((text = subscriber.getTextFromListener()) == null);
               out.println("<h2>Message Received:" + text + "</h2>");
               subscriber.disconnect();
            }
            else {
               String textMessage = request.getParameter("tmessage");
               if (textMessage != null) {
                  JMSPublisher publisher = new JMSPublisher(CONNECTION_FACTORY, TOPIC);
                  publisher.publish(textMessage);
                  publisher.disconnect();
                  out.println("<h2>Message sent !</h2>");
               }
            }
         }

      }
      catch (Exception e) {
         e.printStackTrace();
      }
   }

   /**
    * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
    */
   protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      this.service(request, response);
   }

   /**
    * @see HttpServlet#destroy()
    */
   public void destroy() {
      try {
         broker.stop();
      }
      catch (Exception e) {
         e.printStackTrace();
      }
   }

   /**
    * @param message
    * @return
    * @throws JMSException
    */
   private String getText(Message message) throws JMSException {
      if (message instanceof TextMessage) {
         TextMessage textMessage = (TextMessage) message;
         String text = textMessage.getText();
         return text;
      }
      return null;
   }
}

Yukarıdaki Servlet sınıfı sunucun bir JMS sağlayıcısını nasıl kullandığını ihtiva eder. JMSServlet temel olarak kendisine gelen bir isteğin, bir Topic ya da Queue mesajlaşma isteği olup olmadığına bakar. İlgili durumların bir tanesinde gönderme ya da alma işlemine göre yukarıdaki sınıfların somut uygulamasını gerçekleştirir.

JMSClient Sayfası

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- 

www.fatihkabakci.com 

-->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<script>
    function init() {
        var div_queue = document.getElementById('div_queue');
        div_queue.style.visibility='hidden';
        var div_topic = document.getElementById('div_topic');
        div_topic.style.visibility='hidden';
    }
    
    function radioSet(radio) { 
        var div_queue = document.getElementById('div_queue');
        var div_topic = document.getElementById('div_topic');
        if(radio.value == "Queue"){
            div_queue.style.visibility='visible';
            div_topic.style.visibility='hidden';
        }
        else if(radio.value == "Topic"){
            div_queue.style.visibility='hidden';
            div_topic.style.visibility='visible';
        }
    }
</script>
</head>
<body onload="init()">
Queue <input type="radio" name="qt" value="Queue" onclick="radioSet(this)"> <br/>
Topic <input type="radio" name="qt" value="Topic" onclick="radioSet(this)"><br/>
<div id="div_queue">
<h3>Queue messaging</h3>
    <form id="form_send" method="post" action="JMSServlet" target="_blank;">
            <h3>Click button to send message</h3>
            <input type="text" name="qmessage">
            <input type="hidden" name="queue">
            <input type="submit" name="bsend" value="Send message">
    </form>
    
    <form id="form_receive" method="post" action="JMSServlet" target="_blank;">
            <h3>Click button to receive message</h3>
            <input type="hidden" name="queue">
            <input type="submit" name="breceive" value="Receive message">
    </form>
</div>

<div id="div_topic">
<h3>Topic messaging</h3>
    <form id="form_publish" method="post" action="JMSServlet" target="_blank;">
            <h3>Click button to publish message</h3>
            <input type="text" name="tmessage">
            <input type="hidden" name="topic">
            <input type="submit" name="bpublish" value="Publish message">
    </form>
    
    <form id="form_subscribe" method="post" action="JMSServlet" target="_blank;">
            <h3>Click button to subscribe message</h3>
            <input type="hidden" name="topic">
            <input type="submit" name="bsubscribe" value="Subscribe message">
    </form>
</div>
</body>
</html>

JMSClient, basit bir html sayfasıdır. Temel amacı istemci tarafında çalışan mesaj uç birimlerini yönlendirmektir. Bir gönderici yukarıdaki html formunda mesajını yazarak karşı tarafa gönderir. Mesaj almak isteyen bir kişi de, bu arayüzü kullanarak mesajları alır. Aşağıda bu işlemlerin yapıldığı ekran görüntüleri verilmektedir.

- Queue seçimi

JMS Queue Page


- Mesaj gönderme

JMS Page Message Sending


- Mesajı alma

JMS Page Message Receiving


- Topic seçimi

JMS Topic Page


- Mesaj yayınlama

JMS Page Message Publishing


- Mesaj dinleme

JMS Page Message Subscribing


There has been no comment yet

Name:


Question/Comment
   Please verify the image




The Topics in Computer Science

Search this site for





 

Software & Algorithms

icon

In mathematics and computer science, an algorithm is a step-by-step procedure for calculations. Algorithms are used for calculation, data processing, and automated reasoning.

Programming Languages

icon

A programming language is a formal constructed language designed to communicate instructions to a machine, particularly a computer. It can be used to create programs to control the behavior of a machine. Java,C, C++,C#

Database

icon

A database is an organized collection of data. The data are typically organized to model aspects of reality in a way that supports processes requiring information.

Hardware

icon

Computer hardware is the collection of physical elements that constitutes a computer system. Computer hardware refers to the physical parts or components of a computer such as the monitor, memory, cpu.

Web Technologies

icon

Web development is a broad term for the work involved in developing a web site for the Internet or an intranet. Html,Css,JavaScript,ASP.Net,PHP are one of the most popular technologies. J2EE,Servlet, JSP,JSF, ASP

Mobile Technologies

icon

Mobile application development is the process by which application software is developed for low-power handheld devices, such as personal digital assistants, enterprise digital assistants or mobile phones. J2ME

Network

icon

A computer network or data network is a telecommunications network that allows computers to exchange data. In computer networks, networked computing devices pass data to each other along data connections.

Operating Systems

icon

An operating system is software that manages computer hardware and software resources and provides common services for computer programs. The OS is an essential component of the system software in a computer system. Linux,Windows

Computer Science

icon

Computer science is the scientific and practical approach to computation and its applications.A computer scientist specializes in the theory of computation and the design of computational systems.