wtorek, 27 kwietnia 2010

Wysłanie SMS w Javie

Zaczniemy od ściągnięcia dwóch niezbędnych bibliotek:
Po ściągnięciu i rozpakowaniu pliki .jar kopiujemy do projektu i ustawiamy zależności.

Założenie bezpłatnego konta na ipipi.com
Do wysyłania sms będziemy potrzebowali serwera smtp. Do tego celu możemy założyć konta na ipipi.com. Założenie konta jest darmowe. Do konta dostaniemy możliwość wysłania 3 testowych wiadomości, za kolejne trzeba już niestety zapłacić (kupno pakietu).
Wchodzimy na stronę rejestracji i wypełniamy wszystkie potrzebne pola (login, hasło, email, telefon, imię, nazwisko i kraj). Na podany numer telefony zostanie nam wysłana wiadomość z kodem dostępu który będziemy musieli podać w następnym etapie rejestracji.
Strona rejestracji

Kod klasy
Po założeniu konta możemy napisać naszą pierwsza klasę do wysyłania sms'ów za pośrednictwem ipipi.com.

package com.blogspot.mkorwel.sms;

import java.util.Properties;
import java.util.Date;
import javax.mail.*;
import javax.mail.internet.*;

/**
 * 
 * @author Mateusz Korwel
 * 
 */
public class SMSSend {

 // login z portlau ipipi.com
 private static String USERNAME = "xxx";
 // hasło z portalu ipipi.com
 private static String PASSWORD = "xxxyyyzzz123";
 private static String SMTP_HOST = "ipipi.com";
 // podajemy nazwe swojego konta w serwicie ipipi.com
 private static String FROM = "xxx@ipipi.com";
 // podajemy numer na który wysyłamy sms'a
 private static String TO = "+48123456789@sms.ipipi.com";
 // Wpisujemy temat naszej wiadomości
 private static String SUBJECT = "Moja pierwsza wiadomość";
 // Wpisujemy temat naszej wiadomości
 private static String BODY = "Hello World!!!";

 public static void main(String[] args) {

  SMSSend smsSend = new SMSSend();
  smsSend.sendSMS();
  System.out.println("WIADOMOSZ WYSLANA");

 }

 public void sendSMS() {

  Transport tr = null;

  try {
   // ustawiamy parametry
   Properties props = System.getProperties();
   props.put("mail.smtp.auth", "true");

   // pobieramy sesję obiektu
   Session mailSession = Session.getDefaultInstance(props, null);

   // Tworzymy wiadomość
   Message msg = new MimeMessage(mailSession);
   msg.setFrom(new InternetAddress(FROM));
   msg.setSubject(SUBJECT);
   msg.setText(BODY);
   msg.setSentDate(new Date());

   // ustawiamy odbiorcę wiadomości
   InternetAddress[] address = { new InternetAddress(TO) };
   msg.setRecipients(Message.RecipientType.TO, address);

   tr = mailSession.getTransport("smtp");
   tr.connect(SMTP_HOST, USERNAME, PASSWORD);
   msg.saveChanges();

   // wysyłamy sms'a
   tr.sendMessage(msg, msg.getAllRecipients());
   tr.close();
  } catch (Exception e) {
   System.out.println("Error");
   e.printStackTrace();
  }
 }
}

Jeśli wszystko poszło dobrze możemy cieszyć się wysyłaniem sms'ów.

czwartek, 15 kwietnia 2010

Spring Hello World

W poniższym artykule pokaże jak w bardzo prosty sposób użyć Springa. Do tworzenia kodu użyłem edytora Eclipse z zainstalowaną wtyczką SpringIDE (podaję linka za pomocą którego możemy zainstalować plugin w eclipse http://dist.springframework.org/release/IDE).


Przygotowanie środowiska
Na początek musimy ściągnąć z internetu następujące jary:


Całą paczkę jarów ze springiem można sciągnąć z oficjalnej strony springa.
Kiedy już będziemy mieli je na dysku, proponuję stworzyć w projekcie oddzielny katalog na biblioteki np. lib i umieścić tam ściągnięte jary. Następnie dodajemy biblioteki do projektu.

Tworzenie beana
Zaczniemy od stworzenia prostej klasy która będzie springowym beanem. Tak więc tworzymy pakiet com.blogspot.mkorwel a w nim klase Osoba.java. W klasie Osoba tworzymy pole imie typu String wraz z metodami get i set. Całość powinna wyglądać tak:

package com.blogspot.mkorwel;

/**
 * 
 * @author Mateusz Korwel
 *
 */
public class Osoba {

 private String imie;

 public void setImie(String imie) {
  this.imie = imie;
 }

 public String getImie() {
  return imie;
 }

}

Prosta klasa jest gotowa, aby stała się springowym beanem musimy umieścić odpowiedni wpis w odpowiednim pliku konfiguracyjnym. Tak wiec za pomocą wtyczki SpringIDE tworzymy Spring Bean Configuration File. Klikamy na projekcie prawym przyciskiem, wybieramy New -> Other... -> Spring -> Spring Bean Configuration File




klikamy Next > 




po wpisaniu nazwy (u mnie beans.xml) i kliknięciu Next >




musimy jeszcze wybrać schemę, beans -> spring-beans-3.0.xsd. Po tym wszystkim powinien stworzyć się prosty plik xml w którym będziemy umieszczać wszystkie beany. Cały plik po dodaniu wpisu z naszą klasą Osoba powinien wyglądać tak:

<?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-3.0.xsd">

 <bean id="osoba" class="com.blogspot.mkorwel.Osoba">
  <property name="imie" value="Mateusz"></property>
 </bean>

</beans>

W elemencie bean tworzymy instancje danej klasy według wzorca Singleton (czyli obiekt jednej instancji wykorzystywany w całej aplikacji). W atrybucie id deklarujemy identyfikator beana, a w class podajemy ścieżkę do pliku. Po takiej deklaracji mamy już zainicjalizowaną naszą klasę i możemy jej używać wszędzie w aplikacji. Element property jest opcjonalny i mówi o wartościach z jakimi tworzony jest bean (wywołanie metody setImie (atrybut name) z wartością Mateusz (atrybut value)).

Stworzenie prostego JUnite
Aby przetestować czy bean tworzy się poprawnie, tworzymy prosty JUnite test w którym będziemy wstrzykiwać naszą instancję klasy i sprawdzać czy wartość w polu imię jest Mateusz.
Cały kod testu ma wygląda tak:

package com.blogspot.mkorwel;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * 
 * @author Mateusz Korwel
 * 
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:beans.xml" })
public class OsobaTest {

 @Autowired
 @Qualifier("osoba")
 private Osoba osoba;

 @Test
 public void testImie() {

  Assert.assertEquals("Mateusz", osoba.getImie());

 }

}


Jak widzimy jest to zwykły test JUnit z kilkoma springowymi adnotacjami. Najważniejsza adnotacja to oczywiście @ContextConfiguration która wstrzykuje nam kontekst naszej aplikacji. Możemy sami podać miejsce gdzie jest zlokalizowany nasz plik konfoguracyjny beans.xml poprzez ustawienie pola locations, jesli tego nie zrobimy to aplikacja odwoła się do pliku który znajduje się w tym samym pakiecie co klasa o nazwie naszej klasy z końcówką -context.xml (w naszym wypadku był by to plik com/blogspot/mkorwel/OsobaTest-context.xml). Kolejne dwie ważne adnotacje to @Autowired@Qualifier. Adnotacja @Autowired wstrzykuje nam instancję klasy Osoba do pola osoba, a @Qualifier wskazuje na konkretne id instancji (w wypadku gdy plik beans.xml zawierał by kilka instancji klasy Osoba) która ma zostać wstrzyknięta. Adnotacja @RunWith wskazuje nam klasę z jaką ma się uruchomić test.

poniedziałek, 12 kwietnia 2010

Proste parsowanie XML w Javie

Co to jest XML?
XML (Extensible Markup Language) czyli niezależny od platformy sposób przechowywania, przekazywania pewnej porcji informacji.
Poniżej bardzo prosty przykład pliku XML zawierającego informacje o osobach (imię, nazwisko, płeć):
<?xml version="1.0"?>
<osoby>
  <osoba plec="mężczyzna">
   <imie>Jan</imie>
   <nazwisko>Kowalski</nazwisko>
  </osoba>
  <osoba plec="kobieta">
   <imie>Anna</imie>
   <nazwisko>Nowak</nazwisko>
  </osoba>
</osoby>


Jak skutecznie przetworzyć XML wykorzystując język Java?
Jest wiele API których można użyć do parsowania XML'i, ja pokaże dwa z nich:


  • DOM
  • SAX
DOM
Pierwszy sposób przetwarzania plików XML to Document Object Model, w skrócie DOM. Prosty API dzięki któremu możemy w łatwy sposób przeszukać plik XML i wyciągnąć z niego interesujące nas informacje. Plik XML jest wczytywane w całości do pamięci i odpowiednimi metodami możemy wyciągać z niego informacje nas interesujące. Metoda ta jest oczywiście niezalecana w przypadku dużych plików XML. Zaletą tego rozwiązania jest to, że w każdej chwili mamy dostęp do całego drzewa dokumentu, czyli do wszystkich elementów, atrybutów, wartości, itd.
Poniżej prosty kawałek kodu który czyta plik XML podany we wstępie artykułu.
package com.blogspot.xml.dom;

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * 
 * @author Mateusz Korwel
 *
 */
public class SampleDOM {

  public static void main(String argv[]) {

   try {
   File file = new File("myFile.xml");
   DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
   DocumentBuilder db = dbf.newDocumentBuilder();
   Document doc = db.parse(file);
   doc.getDocumentElement().normalize();

    System.out.println("Element główny: "
     + doc.getDocumentElement().getNodeName());
   
   NodeList nodeLst = doc.getElementsByTagName("osoba");

    for (int s = 0; s < nodeLst.getLength(); s++) {

     Node fstNode = nodeLst.item(s);

     if (fstNode.getNodeType() == Node.ELEMENT_NODE) {

      Element fstElmnt = (Element) fstNode;

      NodeList fstNmElmntLst = fstElmnt
       .getElementsByTagName("imie");
     Element fstNmElmnt = (Element) fstNmElmntLst.item(0);
     NodeList fstNm = fstNmElmnt.getChildNodes();

      NodeList lstNmElmntLst = fstElmnt
       .getElementsByTagName("nazwisko");
     Element lstNmElmnt = (Element) lstNmElmntLst.item(0);
     NodeList lstNm = lstNmElmnt.getChildNodes();

      System.out.println("\n***");
     System.out.println("Atrybut plec: "
       + fstElmnt.getAttribute("plec"));
     System.out.println("Element Imię : "
       + ((Node) fstNm.item(0)).getNodeValue());
     System.out.println("Element Nazwisko : "
       + ((Node) lstNm.item(0)).getNodeValue());
    }

    }
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
}
SAX
Poznaliśmy już bardzo prostą metodę parsowania XML'i łającą pliki do pamięci operacyjnej komputera. Ale co jeśli mamy bardzo duży plik XML którego nie chcieli byśmy w całości wczytywać? W takim wypadku możemy użyć z SAX'a, czyli Simple API for XML. Określamy szereg metod, które wywołują się podczas parsowania pliku XML. Przetwarzanie metodą SAX jest jednokierunkowe.
Poniżej proste dwie klasy korzystające z SAX:
package com.blogspot.xml.sax;

import org.xml.sax.*;
import org.xml.sax.helpers.*;

/**
 * 
 * @author Mateusz Korwel
 * 
 */
public class Handler extends DefaultHandler {

  @Override
 public void startElement(String namespaceURI, String localName,
   String qualifiedName, Attributes att) throws SAXException {
  System.out.println("Znalezione element: " + qualifiedName);
  if (qualifiedName.equals("employee")) {
   System.out.println("Znalezione atrybut: " + att.getValue("name"));
  }
 }

  @Override
 public void characters(char ch[], int start, int length)
   throws SAXException {

   System.out.println("Treść elementu: " + start + " to "
    + (start + length - 1) + ": " + new String(ch, start, length));
 }

}
package com.blogspot.xml.sax;

import javax.xml.parsers.*;
import org.xml.sax.XMLReader;

/**
 * 
 * @author Mateusz Korwel
 * 
 */
public class Sample {

  public static void main(String args[]) throws Exception {

   // Tworzenie parsera
  SAXParserFactory spf = SAXParserFactory.newInstance();
  spf.setNamespaceAware(true);
  SAXParser saxParser = spf.newSAXParser();
  XMLReader parser = saxParser.getXMLReader();

   // Tworzenie klasy Handler
  Handler handler = new Handler();
  parser.setContentHandler(handler);

   // Zaczęćie parsowania dokumentu
  parser.parse("myFile.xml");
 }
}