java project etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster
java project etiketine sahip kayıtlar gösteriliyor. Tüm kayıtları göster

14 Haziran 2015 Pazar

Spring ile sayfa kaynaklarına mapping yöntemiyle erişim

Merhaba, bu yazımda sizlere spring projelerinize kaynak(css, js, png,.. vs) dosyaları nasıl dahil edeceğinizi anlatacağım.

1- öncelikli olarak bir spring web projesi oluşturun.

2- webapp dizini altında resources dizini ve onun altında da erişmek istediğiniz kaynakları  oluşturun
ÖRN: css/custom.css
resources/css/custom.css


3- beans xml dosyasının en üst kısmına(defination yapılan kısma) alttaki  satırları ekleyin. bu sayede spring mvc ile resources mapping (kaynak haritalama-tanımlama) işlemi gerçekleştireceğiz
xmlns:mvc="http://www.springframework.org/schema/mvc"

(xsi:schemaLocation kısmınada bu satırları eklemelisiniz)
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd


4- resoources dizinindeki tüm kaynakları static path olarak map edin.
<!--resources access(mapping)--><mvc:resources mapping="/static/**" location="/resources/"/>
<mvc:annotation-driven/>

üstteki tanımın,  resources/ dizinindeki tüm kaynaklara static sözcüğü(path) ile erişeceğim demektir.


5-  Aşağıdaki şekilde kaynak(css) dosyaları sayfanıza dahil edebilirsiniz.
<link rel="stylesheet" href="${pageContext.request.contextPath}/static/css/custom.css">

6- Aşğağıdaki tanımla da png dosyalarını syfanıza çağırabilirsiniz.
<img src="${pageContext.request.contextPath}/static/img/spring.png" />

sonrasında çağırmak istediğiniz dosyaları yine benzer şekilde çağırabilirsiniz


NOT: Üstteki şekilde map ederek kaynakları sayfalarda çağırmanız durumunda;  oluşan html sayfalarında sağ tıklayıp kaynağı görüntüle dendiğinde kaynak dosyaların gerçek dizinleri değil map edilmiş dizinleri görünecektir. Bu da projenizi güvenlik konularında bir adım daha öne taşıyacaktır.


kaynak dosyalar(github) : indirmek için tıklayın

12 Aralık 2014 Cuma

Netbeans İle Java Application Projesi Oluşturma Ve Palette Hazırlama

Merhaba arkadaşlar,
bu yazımda size netbeans ile palette oluşturmayı göstereceğim.  Bu sayede sürükle bırak yöntemiyle GUI hazırlayabileceksiniz.
Şuan bulunduğumuz noktada Java ile GUI oluşturmak pek tercih edilmese de ara sıra bazı projelerde ihtiyaç olabiliyor.

Normal şartlarda ben geliştirmelerimi intelliJ idea aracılığıyla yapıyorum. Ancak bazı durumlarda diğer IDE ler elimi biraz daha hızlandırıyor.
Bu sebepten ötürü de zaman zaman Eclipse ve Netbeans kullandığım da oluyor.

öncelikle Netbeans ile gui diye bir proje oluşturarak işe başlayalım.

Yeni Proje oluştur.  Choose File > New Project.


Açılan pencereden projenin Java Application projesi olduğunu belirtiyoruz.


Son olarak projenin kurulacağı dizini ve proje adını belirliyoruz.

Oluşturduğumuz projenin üzerine sağ tıklayarak yeni/Diğer seçeneğini seçiyoruz.


Açılan dialog box tan  JFrame Form f seçiyoruz.


•   Class Adı olarak  "NumberAdditionUI"  ve paket adı olarak ta   "my.numberaddition"  giriyoruz.


Projede Palette özelliği eklendi. Artık palet üzerinden gerekli swing ve awt nesneleriyle  sürükle bırak yöntemiyle GUI tasarımı yapabilirsiniz.



Yaptığınız tasarımların kaynak kodlarını alarak projenizde kullanabilirsiniz. 

Kaynak :

kolay gelsin..



11 Aralık 2014 Perşembe

Sistem Değişkeni Oluşturma Ve Komut Satırı Üzerinden JAVA_HOME Değerini Ayarlama

Merhaba herkese,
Bu yazımda Windows üzerinde sistem değişkeni oluşturmayı, değiştirmeyi ve değerlerini görüntülemeyi anlatacağım. Windows ortamında oluşturacağımız değişkenlerin esas yeri kayıt defteridir(Registry).  Ancak bir sistem uzmanı olmadığım için burada çok detaya girmeden işimizi görecek kadarını anlatacağım.  Windows ortamında geliştirme yapan tüm J2ee Developerlar kurulum yaparken ortam değişkeni set etme işiyle mutlaka  uğraşırlar.   Her makine değiştirme işleminden yada her yeni kurulumlar dan sonra bu ayarları yapmak bazen sıkıcı olabiliyor.  Dolayısıyla değişken tanımlama konusu olarak ta JAVA_HOME değerini değiştirmeyi işlememiz de fayda olacağını düşündüm.

JAVA_HOME diye bir sistem değişkeni oluşturacağız ve bu değişkene javanın kök(javayı kurduğumuz) dizinini set edeceğiz.
Öncelikle komut satırı üzerinden  Java home değerini set etmek için alttaki komutu çalıştırmanız yeterli olacaktır. Bu sayede işletim sistem JAVA_HOME’u yoksa oluşturacaktır. Değişken zaten varsa da değerini set edecektir.

Değişken oluşturma:
setx  -m  JAVA_HOME  "C:\Program Files\Java\jdk1.7.0_51"

Windows işletim sistemi üzerinde oturum bazlı değişken, kullanıcı bazlı değişken ve sistem bazlı değişken oluşturabilirsiniz. Yukarıda  setx –m diyerek sistem değişkeni oluşturmuş oldum. 

Değişkenin değerini ekrana yazdırma: 
set JAVA_HOME


Üstte komut satırından yazdığımız kodları  bir text editörü(notepad,notepad++,..vs) aracılığıyla bat uzantılı olarak kaydedip çalıştırırsanız  tekrar kullanmak istediğinizde size büyük kolaylık sağlayacaktır. 

Üstte tek satırda yazdığımız komut yerine manuel olarak JAVA_HOME'u set etmek isteseydik aşağıdaki adımları izlemek durumunda kalacaktık.
Control Panel -> System and Security -> System -> System Properties -> Environment Variables sekmelerini tıklıyoruz.  Açılan penceredeki System Variables penceresinde JAVA_HOME satırı yoksa New düğmesine basıyoruz. Açılan pencerede değişken adı(Variable Name) = JAVA_HOME ve değeri(Variable Value) = "C:\Program Files\Java\jdk1.7.0_51"yazıp OK diyoruz.

Ben artık ilk anlattığım yöntemle ilerliyorum. Bana göre sizde öyle yapın. :)
Kolay gelsin.

19 Eylül 2014 Cuma

Maven Profil Oluşturma (Dev + Preprod + Prod) - 2

Herkese merhaba,
bir önceki yazımda sizlere maven profilinin nasıl oluşturulacağını ve intelliJ ile nasıl profil bazlı compile edileceğini  anlatmıştım. Geçen süre zarfında düşündüm ki ,  sizleri biraz ezberciliğe yönlendirmiş olabilirim. Dolayısıyla konuyla ilgili bir yazı daha yazarak arka planda bu işlerin nasıl ilerlediğini anlatayım istedim. Bu yazım da da komut satırı üzerinden maven profiline göre compile etmeyi anlatacağım.

Kısacası bir önceki  yazıda olan işlemlerin aynısını yapacağız ancak compile ederken maven install butonlarına basmadan bu işlemlerin komutunu yazarak yapacağız.

Öncelikle bir önceki yazımı yazarken oluşturduğum projemi tekrar intelliJ  ile açıyorum. Pom.xml dosyasındaki  profiles tagları arasındaki tüm profiller için  activation tanımlaması yapacağım. Bunun için activation tagları arasında property ve property içinde de name/value tag lerini kullanacağım. Bu sayede profillere birer isim ve bu isimlere birer değer set etmiş olacağız.

  • profiles
    • profile
      • activation
        • property
          • name = env
          • value = Test, Prod yada Dev 
şeklinde bir hiyerarşide olacak.
pom.xml 
<activation>
     <property>
          <name>env</name>
          <value>Test</value>
     </property>
</activation>

Basitçe şöyle düşünebilirsiniz : env diye bir değişken tanımlayıp ve değerini Test olarak set ediyoruz.

şimdi komut satırı üzerinden cd komutuyla projenin kodlarının olduğu dizine gidelim


başlangıçta   
mvn help:active-profiles
 komutunu çalıştırarak varsayılan da hangi profil ile compile edildiğine bakıyoruz(sonuç aşağıdadır).



hemen ardından  
mvn -Denv=Test help:active-profiles
 komutuyla aktif profili önce Test olarak set ettim. Daha sonrada aktif profili tekrar ekrana yazdırdım.


Son olarak ta alttaki komutla profili test olarak set edip projemizi compile edelim.
mvn -Denv=Test install

Bu işlemlerden sonra projenin  target dizini altında oluşan war dosyası artık test profiline göre hazırlanmıştır. Test sunucusuna deploy edebilirsiniz.. :)


kaynak dosyalar(github) : indirmek için tıklayın

15 Eylül 2014 Pazartesi

Maven Profil Oluşturma (Dev + Preprod + Prod)

Herkese merhaba bu yazımda maven ile profil oluşturma dan bahsedeceğim. Biraz uzun fakat ehemmiyeti büyük olan bir yazı olacak. Bir senaryo üzerinden örnekleme yaparak anlatacağım maven profile kullanmayı. Bu arada bir parantezle  belirtmek istiyorum ki Java ile geliştirme yaparken maven kullanan yada kullanacak olan herkese  maven profile kullanmalarını kesinlikle ve şiddetle tavsiye ediyorum.

Maven profile ne amaçla kullanıldığıyla ilgili internetten çeşitli araştırmalar yapabilirsiniz. Ben çok detaya inmeden kendi kullanımımı anlatacağım size.

Java ile geliştirme yaptığım her projede 3 farklı profilim olur benim.  dev , prep ve prod diye..

  • dev  : Development(geliştirme yaptığım) ortamını ifade eder
  • prep : preProduction dan gelir. Test ortamını ifade eder.
  • prod : production ortamını ifade eder.
Peki neden 3 farklı profil size kısaca anlatayım. Öncelikle genel olarak şirketlerde kodları geliştirdiğiniz bir makine oluyor(Bu size verilen laptop). Geliştirme işlemleri bitince sizden geliştirme isteyenlerin kodlarınızı görebilmesi ve test uzmanlarının sizin geliştirdiğiniz kodu test edebilmesi için bu projeye ait bir test sunucusu oluyor. Birde testlerden onay alındıktan sonra amacına hizmet etmek üzere kodları attığınız gerçek(Erişime açılan) sunucular...

Bir projenin geliştirilip yayına çıkması bu 3 aşamadan geçerek gerçekleşir. Dolayısıyla siz geliştirme yaparken localde kullandığınız veri tabanı bilgileri ayrı, testte kullandıklarınız ayrı ve prodda kullandıklarınız ayrı olacaktır. Bu farklılıklara istinaden projenizi deploy ederken ya her sunucunun bilgilerini elle güncelleyip, compile edip, deploy edeceksiniz, yada birazdan göstereceğim şekilde  maven ile profil oluşturarak bu üç farklı sunucu için üç farklı ayar dosyası oluşturacaksınız. Ve compile ederken profil seçeceksiniz.
Kısacası ; localde çalışırken maven'a kodlarımı dev profiline göre compile et, teste giderken prep'e göre ve son olarak production a çıkarken prod'a göre compile et diyeceksiniz..

NOT : Bu yazıyı sadece  4 satırlık veri tabanı ayar dosyaları üzerinden örneklendiriyorum ancak gerçek ortamlarda kod yazarken bu ayar dosyalarının farklılıkları onlarca satırı bulur ve eğer profil kullanmazsanız her deploy etmede(dev+test+prod) bu onlarca satır kodu ilgili sunucuya göre değiştirmek durumunda kalırsınız. 

şimdi örneklendirmeye geçiyorum.Geliştirme yaptığımız ortamda(development) bir  MySQL veri tabanımız   olsun erişim bilgileri aşağıdaki gibi olsun 
url   : localhost
user : root 
pass : 12345 

Birde bu geliştirmeleri yaptıktan sonra tester ların bu kodları test edebilmesi için bir test sunucusu olduğunu ve  tabi bu sunucu içinde bir test veri tabanımız olsun.
url   : 192.168.1.110
user : rootTest 
pass : 12345Test 

son olarak geliştirmeyi yaptık, testlerden geçti ürünün yayınlandığı gerçek ortam(production) olacak birde.
url   : 192.168.1.111
user : rootProd
pass : 12345Prod 


Hemen intelliJ ile bir web(Spring MVC) projesi oluşturup projemizi geliştirmeye başlayalım.

projenin son hali aşağıdaki yapıda olacaktır:


İlk olarak resources dizini altında üç profili ayırmak için üç dev , prod ve prep diye üç farklı dizin oluşturuyoruz. Her üç dizinin altında da config.properties dosyasını oluşturuyoruz.

Bu işlemlerden sonra xml dosyasında config dosyasını load edecek şekilde ayarlıyoruz. Bu işlemler için alttaki parametreyi mvc-dispatcher-servlet.xml dosyasına eklemek yeterlidir(classpath ten sonra gelen tüm .properties uzantılı dosyaları yükle anlamı taşır).

mvc-dispatcher-servlet.xml
    <context:property-placeholder location="classpath*:*.properties"/>

bu tanımlamayı yaptıktan sonra config.properties dosyalarını aşağıdaki şekilde düzenliyoruz.

dev/config.properties
db.url = localhost
db.user = root
db.pass = 12345

 prep/config.properties
db.url = 192.168.1.110
db.user = rootTest
db.pass = 12345Test

prod/config.properties
db.url = 192.168.1.111
db.user = rootProd
db.pass = 12345Prod



ayar dosyalarını da tanımladıktan sonra , controller'a giderek yüklenen ayar dosyasındaki değerleri okuyalım.


 HelloController.java

@Controller
@RequestMapping("/")
public class HelloController {

    @Value("${db.url}")
    public String dbUrl;


    @Value("${db.user}")
    public String dbUser;


    @Value("${db.pass}")
    public String dbPass;



                @RequestMapping(method = RequestMethod.GET)
                public String printWelcome(ModelMap model) {
                               model.addAttribute("message", "Okunan Degerler!");
        model.addAttribute("url",this.dbUrl);
        model.addAttribute("pass",this.dbPass);
        model.addAttribute("user",this.dbUser);

                               return "index";
                }
}



son olarak okunan değerlerin view edilmesi için index.jsp sayfasına aşağıdaki kodları ekleyelim.
index.jsp
                <h3>${message}</h3>
                <p><b> user :</b>${user}</p>
                <p><b> pass :</b>${pass}</p>
                <p><b> url: </b>${url}</p>



Kodlamamız buraya kadardı ancak bizim maven'a giderek profil tanımlamasını  henüz yapmadık. Üstte üç farklı dizine ayırdığımız ayar dosyalarını profillerle eşleştirmemiz gerekmektedir.  Bu tanımlamayı yapmak için pom.xml e aşağıdaki kodları ekleyelim.



 pom.xml
    <profiles>
        <profile>
            <id>dev</id>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
            <build>
                <resources>
                    <resource>
                        <directory>src/main/resources/dev</directory>
                    </resource>
                </resources>
            </build>
        </profile>
        <profile>
            <id>prep</id>
            <build>
                <resources>
                    <resource>
                        <directory>src/main/resources/prep</directory>
                    </resource>
                </resources>
            </build>
        </profile>
        <profile>
            <id>prod</id>
            <build>
                <resources>
                    <resource>
                        <directory>src/main/resources/prod</directory>
                    </resource>
                </resources>
            </build>
        </profile>
    </profiles>

Buradaki komutlarla maven'a  dev,prep ve prod diye 3 profil ID si verdik. bu profillerin ayar dosyalarının nerede olduğunu belirttik. Üstteki kodları pom.xml e ekledikten sonra sağ üste köşedeki maven tabında profil bilgileri listelenecektir. Burada hangi profili seçip maven install dersek artık  maven  o profile ait ayar(config.properties) dosyasını okuyarak war dosyası oluşturacaktır.


 Her profil için maven clean deyip ardından maven install ettikten sonra projeyi çalıştırınca  oluşan  3 farklı (profile göre) çıktı aşağıdaki gibi olacaktır.




kaynak dosyalar(github) : indirmek için tıklayın


14 Eylül 2014 Pazar

Spring MVC ve JSLT ile controllerdan(java) view'a(jsp) değer göndermek-2 (Foreach + If)

Merhaba, bir önceki yazımda controllerdan aldığımız değerleri view katmanında nasıl listeleyeceğimizi görmüştük. Bu yazımda ise sizlere controllerdan set edilen değerleri listelerken If kontrolünün nasıl yapılacağını ve array lerin nasıl listeleneceğini inceleyeceğiz.

Yine intelliJ ile bir web(spring MVC) projesi oluşturarak işe başlayacağız.
projemizin bitmiş halinin görünümü(Hiyerarşik yapı) aşağıdaki gibi olacaktır.



ilk olarak controllerda bilgiler ve diller diye iki farklı arrayList tanımladım. diller ; programlama dilleri bilgisini tutacak  , bilgiler ise kişi bilgilerini(ad,soyad) tutacak.
NOT: Normal şartlarda bilgileri arrayListte tutmak size anlamsız gelebilir ancak jsp(view) sayfasında farklı iki foreach ve if kullanımına yer verdim. Kullanımlardaki farklılıkları daha kolay inceleyebilmeniz için böyle bir yöntem tercih ettim.

ListController.java 
    @RequestMapping(value = "/", method = RequestMethod.GET)
    public ModelAndView index() {
        ModelAndView mv = new ModelAndView("index"); // index sayfasına gider

        HashMap<String, String> hashMap = new HashMap<String, String>();
        hashMap.put("adi", "Levent");
        hashMap.put("soyadi", "YILDIZ");

        ArrayList bilgiler = new ArrayList();
        bilgiler.add(hashMap);

        mv.addObject("bilgiler", bilgiler);

        List<String> list = new ArrayList<String>();
        list.add("C");
        list.add("Java");
        list.add("C++");
        list.add("C#");
        list.add("phyton");

        mv.addObject("diller", list);

        return mv;
    }


bu bilgileri ekrana basabilmek için yine bir önceki yazımda olduğu gibi jslt yi maven'a ekliyoruz.
pom.xml
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>



maven'a ekledikten sonra yine jsp sayfasının en üstünde jslt core'u çağırıyoruz.

index.jsp
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>


bu işlemlerden sonra arraylist'i foreach ile ekrana basabiliriz.

index.jsp
<%--kullanım 1--%>
<c:forEach var="bilgi" items="${bilgiler}">
    <c:choose>
        <c:when test="${bilgi.adi!=null && bilgi.adi!=''}">
            <p> Adi :  ${bilgi.adi} &nbsp;</p>
        </c:when>
    </c:choose>
    <c:choose>
        <c:when test="${bilgi.soyadi!=null && bilgi.soyadi!=''}">
            <p> Soyadi :  ${bilgi.soyadi} &nbsp;</p>
        </c:when>
    </c:choose>
</c:forEach>


 index.jsp
<%--kullanım2--%>
<c:if test="${not empty diller}">

    <ul>
        <c:forEach var="listLangs" items="${diller}">
            <li>${listLangs}</li>
        </c:forEach>
    </ul>

</c:if>


üstteki kodları projenize ekleyip çalıştırdığınızda controllerdan doldurulan diller(Programlama Dilleri)  ve bilgiler(Kullanıcı Bilgileri) ekrana yazdırılacaktır. Ekran çıktısı aşağıdaki gibi olacaktır.

kaynak dosyalar(github) : indirmek için tıklayın

25 Temmuz 2014 Cuma

Tomcat'i restart etmeden intelliJ de değişikliklerin algılanması

Merhaba,
bugün kü yazımın konusu  intelliJ ile geliştirme yaparken tomcati restart etmeden değişikliklerin algılanmasını sağlamak olacak. Önceki yazılarımdan birinde anlattığım ve bildiğinizi düşündüğüm üzere intelliJ ile web projesi geliştirirken  geliştirdiğiniz kodların tomcat'a deploy edilmesi için run tuşuna basarak sunucuyu restart edip kaynakları güncellemeniz gerekmektedir(Ayarların varsayılan ayarlar olduğunu düşünürsek).
Ancak aşağıdaki yapacağımız ayarlarla siz geliştirmeyi bitirip browser'u refresh eder etmez kaynaklar güncellenmesini sağlayacağız. Toplumumuzun(Türk toplumu) okumaktan çabuk sıkılacağını  göz önünde bulundurarak işlemleri sırasıyla ve  ekran görüntüleriyle anlatıyorum. :) 

İlk olarak Üstteki File menüsünden settings seçeneğine tıklanır. 
Kısa yolu : CTRL + ALT + S


Karşımıza gelen ekranda
Ide Settings / Debugger / HotSwap  seçeneğine gelinerek  en alttaki "Reload Classes After Compilation (Derleme işleminden sonra sınıfları tekrar yükle/güncelle)"  ayarını Always olarak set edip OK butonuna basıyoruz.


Daha sonra alttaki ekran görüntüsünde ki gibi run/edit configuration'a tıklayarak çalıştırma ayarlarını açıyoruz.



Burada öncelikle deployment tabına gelinerek set edilen eski ayarlar kaldırılmalıdır. Bunun için alttaki ekrandaki gibi projenin war dosyasını seçip eksi(-)/sil butonuna basılıp ardından da değişikliklerin aktif olabilmesi için OK butonuna basılır.

Daha sonra server tabına gelinerek sağ alt köşede ki fix butonuna basılarak projenin exploded olan war dosyası seçilir. (projeadi.war exploded şeklinde yazar) yine değişiklikleri aktif etmek için OK butonuna basarak kaydederiz.



Son olarak tekrar server tabına gelerek
On Update Action (güncelleme işleminde): update classes and resources (class ve kaynakları güncelle)
On Frame Deactivation(pencere pasif olduğunda) : Update Classes And Resources(Class ve Kaynakları güncelle) burada anlatılmak istenen şudur: intelliJ ekranında geliştirme yapıyorken mouse ı başka bir yere tıkladığınızda(ÖRN: chrome geçtiniz) hemen kaynaklar ve class lar güncellenir

Ayrıca show dialog  seçeneği pasif konuma getirilmelidir.


Bu ayarlardan sonra  tomcat restart olması  tüm değişikliklerin algılanması için proje run edilir. Tomcat restart  işleminden sonra artık  intellij de yaptığımız değişiklikleri takip edebilmek için browserı refresh etmemiz yeterli olacaktır.

19 Temmuz 2014 Cumartesi

Spring MVC ile Hello World

Merhaba, önceki yazımda intelliJ aracılığıyla spring projeleri oluşturmuştuk. Hatta intellij'nin bize yol göstermek  için  ekrana HelloWorld yazan örnek bir kodlama yaptığından bahsetmiştik.
NOT: Bu kodları inceleyerek java da spring aracılığıyla ekrana mesaj vermenin nasıl olacağı konusunda fikir edinebilirsiniz. ayrıca bu kodların ne anlama geldiğini açıkladığım  yazıyı inceleyebilirsiniz.

Bu yazımda Spring  ile ekrana HelloWorld mesajının nasıl yazdırılacağını anlatacağım.  Yazının uzun olmasını istemediğimden hemen kodlamaya geçmek istiyorum.

ilk olarak  intelliJ ile bir web projesi oluşturuyoruz.
oluşturduğumuz projenin son hali aşağıdaki gibi olacaktır.


oluşturduğumuz projede spring framworku kullanmak için maven install komutunu çalıştırmamız gerekiyor.
Maven tabına gelerek(varsayılan olarak intellij geliştirme ekranın sağ tarafında yer alır) install butonuna basıyoruz.


ikinci aşamada projede src/main/webapp/WEB-INF/pages dizinine gelerek burada  welcome.jsp adında bir jsp dosyası oluşturuyoruz.

welcome.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title></title> </head> <body> Hello World </body> </html>

hemen ardından bu jsp dosyamızı view edecek controller dosyasını oluşturmamız lazım. projede src/main/java/ dizini altındaki com.company.controller paketine sağ tıklayarak
new/java class seçeneği ile WelcomeController  adında bir java dosyası oluşturuyoruz.
intellij de yeni class oluşturmanın kısa yolu:
ALT + 1  
ALT + insert




WelcomeController.java (Controller in ilk harfini ve ardından gelen her yeni kelimenin ilk harfini büyük harfle yazmak yazılım geliştirme standartlarındandır.)
package com.company.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; //sınıfın controller olduğunu belir @Controller public class WelcomeController { //URL deki /welcome parametresini görünce welcome metodunu çağır @RequestMapping(value = "/welcome" , method = RequestMethod.GET) public String welcome(){ return "welcome"; } }

üstteki WelcomeController.java da ve alttaki ayar dosyalarının derlenmesi sonucu Spring framework base URL(localhost:8080) den sonra /welcome görürse hemen welcome() metodunu çağıracak. bu metod bize görüntülemek istediğimiz jsp sayfasının adını döndürecektir.



web.xml
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <display-name>Spring MVC Application</display-name> <!--ilk olarak mvc-dispatcher yükle--> <servlet> <servlet-name>mvc-dispatcher</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <!--tüm url de eşleştirme yap(tarama yap)--> <servlet-mapping> <servlet-name>mvc-dispatcher</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app>


mvc-dispatcher-servlet.xml
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!--varsayıaln paket // spring başlaması için--> <context:component-scan base-package="com.company.controller"/> <!--jsp dosyalarını çağırırken /WEB-INF/pages/dosyadi.jsp şeklinde çağır--> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/pages/"/> <property name="suffix" value=".jsp"/> </bean> </beans>

NOT:  web.xml ve mvc-dispatcher-servlet.xml dosyalarında kodsal  değişiklik hiç yapmadım. Sadece daha anlaşılır olması adına bu dosyaların içinde yorum satırları yazdım.

üstteki kodları içerin projeyi çalıştırdığımızda ekranda HelloWorld mesajını yazacaktır.
URL : http://localhost:8080/welcome 
örnek görüntü aşağıdadır:



kaynak dosyalar : indirmek için tıklayın

İntellij ile web projesi oluşturma - (Açıklamalar)

Merhaba,
önceki yazılarımdan birinde size intellij ile web projesinin nasıl oluşturulacağını anlatmıştım. Projeyi oluşturduktan sonra intellij nin bazı dosyaları bize yol göstermek için kendisinin oluşturduğunu da belirtmiştim.
Bu yazımda da bir web projesi oluşturduğumuzda gelen dosyaların ve içindeki değerlerin ne anlama geldiğini paylaşıyor olacağım.

Dosya içeriklerini yorum satırlarıyla birlikte paylaşıyorum. Eğer yorumların renklendirilmiş olarak görmek istiyorsanız dosya içeriklerini intellij ye taşıyarak okuyun bu şekilde size renklendirilmiş görünümde daha anlaşılır gelebilir. Yada alttaki kaynak dosyaları indirip intellij ile açıp inceleyin.

NOT: Kafa karışıklına neden olmasın diye içeriklerin tamamının açıklamasını yazmadım. Şuan için açıklaması yapılanları bilmek yeterlidir. ilerleyen dönemlerde zaten tüm içerikleri bir bir ele alıyor olacağız.


  • MVC deki view kısmı olan hello.jsp dosyası. Controller dan gelen değerleri ekrana basar. 
ornek1\src\main\webapp\WEB-INF\pages\hello.jsp
<html> <body> <%--jsp de controller dan dönen mesajı ekrana yazmak için ${mesaj} kullanılır. yani dolar($) ve süslü parantezler{} arasına controller dan dönen değişken yazılır. örn olarak aşağıda controllerdan dönen message değişkeni ekrana yazdırılmaktadır.--%> <h1>${message}</h1> </body> </html>



  • MVC nin controller kısmıdır. tüm kontroller burada yapılır ve view'a değer gönderilir.
ornek1\src\main\java\com\company\controller\HelloController.java
package com.company.controller; import org.springframework.stereotype.Controller; import org.springframework.ui.ModelMap; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; //@controller antotation u ile sınıfımızın bir control sınıfı olduğunu belirtti @Controller //@RequestMapping("/") ile localhost:8080/ dan sonra gelecek tüm değerlerde bu metodun çağrılacağını bildirttik. //eğer @RequestMapping("/login") desyedik localhost:8080/login değerinin geleceğini ifade etmiş olacaktık. @RequestMapping("/") public class HelloController { //Gelecek olan değerlerin GET metoduyla beklediğimizi @RequestMapping(method = RequestMethod.GET) ile belirttik @RequestMapping(method = RequestMethod.GET) public String printWelcome(ModelMap model) {//methoda ModelMap türümde bir parametre tanımadık //ModelMap olarak tanımladığımız model'e message diye bir anahtar ekliyoruz. ve bu anahtarın değeri ni Hello World olarak set ediyoruz. // burada model.addAttribute("name", "aliveli"); desyedik model'e name i aliveli olan değer eklemiş olacaktık model.addAttribute("message", "Hello world!"); //string olarak gideceğimiz sayfanın adını döndürüyoruz. burada hello değilde return home deseydik /WEB-INF/pages/ dizininde home.jsp sayfasına yönlendirmiş olacaktık return "hello"; } }




  • java da web projelerinin ayarlarının yapıldığı web.xml dosyasıdır.
src\main\webapp\WEB-INF\web.xml
<web-app version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

<display-name>Spring MVC Application</display-name>

    <!--mvc-dispatcher-servlet.xml dosyasını web.xml dosyasının içinde çağırıyoruz.-->
    <servlet>
<servlet-name>mvc-dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--ilk yüklenecek olan servlet oalrak belirle-->
        <load-on-startup>1</load-on-startup>

</servlet>

    <!--/ koyarak http://localhost:8080/ den sonra tüm değerlerde buradaki kuralları uygula-->
<servlet-mapping>
<servlet-name>mvc-dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>




  • Java da yine bir ayar dosyasıdır. bu dosya web.xml aracılığıyla çağrılır.
ornek1\src\main\webapp\WEB-INF\mvc-dispatcher-servlet.xml
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!--spring in ayağa kalkarken hangi paket ile projeye dahil olacağını burada set ederiz. aşağıdaki tanımda spring com.company.controller paketinde projeye giriş yapar.--> <context:component-scan base-package="com.company.controller"/> <!--spring projemizin jsp dosyalarına erişimi sağlarken baseURL(localhost:8080) den sonra gelen değerin önüne /WEB-INF/pages/ parametresini sonuna da .jsp parametresini ekler ne demek bu? örn: login sayfasına erişmek için siz localhst:8080/login yazdığınızı varsayarsak. spring login değerinden önce ve sonra gelecek değerleri hesap ederek /WEB-INF/pages/login.jsp ye dönüştürecektir. yani /WEB-INF/pages/ dizininin altında login.jsp sayfası arayacaktır --> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/pages/"/> <property name="suffix" value=".jsp"/> </bean> </beans>



  • Daha iyi anlatabilmek için başka nasıl bir tanımlama getirmek gerektiğini bilmiyorum ama şuan için asistan maven için yeterince açıklayıcıdır diye düşünüyorum :) pom.xml sayesinde bize projede lazım olan dosya adlarını  bu asistana belirtiyoruz. 
unutmayın maven install dediğimizde bu asistan pom.xml deki tüm tanımlı dosyaları indirip projeye dahil ediyor.
ornek1\pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.springapp</groupId> <artifactId>ornek1</artifactId> <!--war dosyası olarak output oluştur--> <packaging>war</packaging> <version>1.0-SNAPSHOT</version> <!--projenin adı--> <name>ornek1</name> <properties> <!--<properties> tagları arasında genellikle versiyon belirtimi olmak üzere--> <!--bu dosyanın(pom.xml) alt satırlarında birden fazla tekrar edecek olan özellikler tanımlanır.--> <!--spring versiyonunu bir değişken gibi kullanmak için <spring.version> tagları arasında kullanacağımız spring versiyonunu belirttik--> <spring.version>3.2.0.RELEASE</spring.version> <!--üstte <spring.version> tagı ile kullanacağımız spring versiyonunu 3.2.0.RELEASE olarak set ediyoruz. bu tanımalamadan sonra--> <!--dependency tagları arasında <version>${spring.version}</version> yazarsak maven otomotik olarak bizim 3.2.0.RELEASE--> <!--kastettiğimizi anlamış olacaktır--> </properties> <dependencies> <!--dependency(Bağımlılık) maven nedir adlı yazımda maven in bir asistan gibii çalıştığından bahestmiştik.--> <!--işte asistanın bağımlılıkları burada tanımlanıyor. dependency tagları arasında yazdığımız herşeyi maven projemizin yanında getiriyor.--> <!--core spring frameworkünü kullanacağımızı ve bu frameworkün dosya/jar larını bize getirmesini maven a bildiriyoruz--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <!--aynı şekilde spring in web tarafında ihtiyacımız olduğunu asistanımız maven'a söyledik--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>${spring.version}</version> </dependency> <!--servlet-api ye projede ihtiyacımız olduğunu belirttik--> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> </dependency> <!--jsp api --> <dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>jsp-api</artifactId> <version>2.1</version> <scope>provided</scope> </dependency> <!--spring-web (Model View Controler)--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${spring.version}</version> </dependency> <!--spring test --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>${spring.version}</version> <scope>test</scope> </dependency> <!--juint test--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.8.2</version> <scope>test</scope> </dependency> </dependencies> <!--build tagları ile projenin nasıl derleneceğini belirtiriz--> <build> <!--ornek1 olarak çıktı oluşturur--> <!--bu output projeyi oluşturduğumuz dizinin altında ornek1/target/ornek1.war şeklindedir--> <finalName>ornek1</finalName> <plugins> <plugin> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>1.6</source> <target>1.6</target> </configuration> </plugin> <plugin> <artifactId>maven-surefire-plugin</artifactId> <configuration> <includes> <include>**/*Tests.java</include> </includes> </configuration> </plugin> </plugins> </build> </project>

kaynak dosyalar : indirmek için tıklayın