<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by oguzhanozgokce on Medium]]></title>
        <description><![CDATA[Stories by oguzhanozgokce on Medium]]></description>
        <link>https://medium.com/@ozgokceoguzhan?source=rss-2331c975c5c5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*l3S6fs2_I-RwjJ-ww6CXyw.jpeg</url>
            <title>Stories by oguzhanozgokce on Medium</title>
            <link>https://medium.com/@ozgokceoguzhan?source=rss-2331c975c5c5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 00:57:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ozgokceoguzhan/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Android Developer’dan Backend Developer’a: Spring Boot ile Modern REST API Geliştirme Rehberi]]></title>
            <link>https://ozgokceoguzhan.medium.com/android-developerdan-backend-developer-a-spring-boot-ile-modern-rest-api-geli%C5%9Ftirme-rehberi-bfeca8ce6208?source=rss-2331c975c5c5------2</link>
            <guid isPermaLink="false">https://medium.com/p/bfeca8ce6208</guid>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[oguzhanozgokce]]></dc:creator>
            <pubDate>Fri, 11 Jul 2025 15:11:34 GMT</pubDate>
            <atom:updated>2025-07-11T15:11:34.232Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><strong>“Tek başıma bir uygulama geliştirmek istiyorum ama backend bilmeden olmuyor.” </strong>Bu cümle tanıdık geldiyse, seni içeri alalım.</blockquote><p>Mobil uygulama geliştiriyorsunuz, Retrofit ile API çağrıları yapıyorsunuz…<br> Ama o çağrıların arka tarafı nasıl çalışıyor hiç merak ettiniz mi?</p><p>Bu yazıda, <strong>Android geliştirici gözüyle Spring Boot kullanarak backend dünyasına adım atacağız.</strong><br>Kayıt, giriş, kullanıcı yönetimi gibi işlemleri adım adım geliştirip, Android tarafında bu servisleri nasıl tüketeceğimizi birlikte göreceğiz.</p><p>Yani sadece teori değil, gerçekten <strong>çalışan bir full-stack yapı</strong> kuracağız:<br> ➡ Backend’i yazacağız → Android’de test edeceğiz.</p><h3>Neden Backend de Bilmeye Başlamalısınız?</h3><p>Mobil geliştirme harika bir alan ama sadece client tarafında kalmak sizi bazı noktalarda sınırlar.</p><p>Backend’e adım atmak ise size birçok açıdan katkı sağlar:</p><ul><li><strong>Özgürlük:</strong> Artık “backend hazır değil” bahanesi yok. Projeyi baştan sona geliştirebilirsiniz.</li><li><strong>Anlayış:</strong> API’lerin nasıl çalıştığını bildiğinizde daha bilinçli ve optimize çözümler üretirsiniz.</li><li><strong>Hız:</strong> Prototipleri çok daha kısa sürede çıkarabilirsiniz.</li><li><strong>Kariyer:</strong> Full-stack yaklaşım sizi hem teknik hem de iş piyasasında birkaç adım öne taşır.</li></ul><h4>Neden Özellikle Spring Boot?</h4><p>Backend’e adım atarken karşınıza birçok seçenek çıkacak: Node.js, Django, Express, .NET Core… Peki ben neden özellikle <strong>Spring Boot</strong> öneriyorum?</p><p>Kısa cevap: Android geliştiricisiyseniz, zaten eliniz güçlü. Çünkü Spring Boot size oldukça tanıdık gelecek.</p><p><strong>Karşılaştıralım</strong>:</p><pre>@RestController<br>public class UserController {<br>    @GetMapping(&quot;/users&quot;)<br>    public List&lt;User&gt; getUsers() {<br>        return userService.getAllUsers();<br>    }<br>}</pre><p>Node.js/Express:</p><pre>app.get(&#39;/users&#39;, (req, res) =&gt; {<br>    userService.getAllUsers()<br>        .then(users =&gt; res.json(users));<br>});</pre><h4>Peki Spring Boot’un avantajları neler?</h4><ul><li><strong>Java tabanlı:</strong> Android’de zaten Java/Kotlin ile çalışıyorsunuz. Söz dizimi tanıdık, öğrenme eğrisi düşük.</li><li><strong>Annotation temelli:</strong> @RestController, @GetMapping gibi yapılar; tıpkı Android’deki @Override, @Inject, @Nullable gibi.</li><li><strong>Zengin ekosistem:</strong> JVM dünyası sayesinde çok güçlü bir kütüphane desteği var.</li><li><strong>Enterprise-ready:</strong> Spring Boot büyük projelerde, kurumsal yapılarda kendini kanıtlamış bir teknoloji.</li><li><strong>Otomatik konfigürasyon:</strong> Spring Boot sizi konfigürasyonla boğmadan hızlıca işe odaklanmanızı sağlar.</li></ul><h3>Yazıda Neler Yapacağız?</h3><p>Bu yazıda gerçek bir senaryo üzerinden backend + Android entegrasyonu yapacağız. Sadece teori değil, gerçekten çalışan bir proje geliştireceğiz.</p><h4>Pratikte Neler Olacak?</h4><ul><li><strong>Kayıt &amp; Giriş:</strong> Android → Spring Boot → Database</li><li><strong>JWT Token:</strong> Giriş sonrası token alımı &amp; saklama</li><li><strong>Profil Güncelleme:</strong> Auth ile veri gönderme örneği</li><li><strong>Logout:</strong> Token geçersizleştirme işlemi</li></ul><h4>Kullanacağımız Teknolojiler</h4><ul><li><strong>Backend:</strong> Spring Boot, Security, JPA, H2 DB</li><li><strong>Android:</strong> Retrofit, OkHttp, Gson, SharedPreferences</li><li><strong>Araçlar:</strong> Postman, IntelliJ, Android Studio</li></ul><p>Hazırsanız, Spring Boot projemizi kurarak başlayalım! 🙌</p><h3>Spring Boot ile Proje Oluşturma</h3><p>İlk adımımız, backend projemizi oluşturmak. Bunun için <strong>IntelliJ IDEA</strong> üzerinden hızlıca bir Spring Boot projesi başlatıyoruz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ztvqAgwRb5vj4Mvd8lWMzA.png" /></figure><p><strong>Dependency Seçimi</strong></p><p>Şimdi sıra, projeye hangi özellikleri ekleyeceğimizi seçmeye geldi. Aşağıdaki gibi birkaç önemli bağımlılığı ekliyoruz:</p><ul><li><strong>Spring Boot DevTools:</strong> Geliştirme sırasında otomatik yeniden başlatma vs. için</li><li><strong>Spring Web:</strong> REST API oluşturabilmek için</li><li><strong>Spring Security:</strong> Giriş, token doğrulama gibi işlemler için</li><li><strong>H2 Database:</strong> Veritabanı bağlantısı için</li></ul><p>Bu bağımlılıklar bizim temel ihtiyaçlarımızı karşılayacak. Ek olarak proje ilerledikçe yeni ihtiyaçlara göre güncelleme yapabiliriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9zU4vCszlofFW6re1HkXOQ.png" /></figure><h3>Proje Yapısını Tanıyalım</h3><p>Spring Boot projesi oluşturduğunuzda karşınıza çıkan temel yapıyı şöyle özetleyebiliriz:</p><ul><li>src/main/kotlin: Uygulamanızın asıl Kotlin dosyalarının yer aldığı klasör. Controller, Service, Repository gibi katmanları burada oluşturacağız.</li><li>src/main/resources: Uygulama ayarlarının yapıldığı dosyalar burada bulunur. Örneğin application.properties ya da application.yml dosyası.</li><li>build.gradle: Proje bağımlılıklarını yönettiğimiz Gradle yapılandırma dosyası.</li></ul><h3>Spring Boot Mimarisi: MVC Pattern</h3><p>Artık yavaş yavaş kod yazma aşamasına geliyoruz. Ama aklınızdan şu geçiyor olabilir:</p><blockquote><em>“Kodları yazacağız ama hangi yapıya göre yazacağız?”</em></blockquote><p>Bu çok yerinde bir soru. Çünkü backend dünyasında, özellikle de <strong>kurumsal projelerde</strong>, belirli mimari kalıplar kullanılır. İşte bunlardan biri de: <strong>MVC (Model-View-Controller)</strong> mimarisi.</p><p>Bu bölümde Spring Boot projemizi bu yapıya göre organize edeceğiz. Hadi birlikte temel bileşenleri tanıyalım</p><h4>MVC Nedir?</h4><p>MVC, yani <strong>Model-View-Controller</strong>, bir yazılım projesinin katmanlara ayrılarak geliştirilmesini sağlar.<br>Android’deki <strong>MVVM</strong> yapısına oldukça benzer: Sorumluluklar ayrılır, kod tekrarları azalır, test edilebilirlik artar.</p><p>Sizler için MVC mimarisinin görsel diyagramını hazırladım görsel de görmek daha akılda kalıcı olabiliyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1Px0JS15ZWXlj_WcfPz8BA.png" /></figure><p>Aşağıda projede kullanacağımız tüm katmanları ve görevlerini özetledim:</p><p><strong>Client (İstemci Tarafı)</strong></p><p>API’ye HTTP istekleri gönderen dış dünya. Bu bizim örneğimizde:</p><ul><li>Postman</li><li>Android uygulamanız (Retrofit ile)<br>kullanılarak register, login gibi istekleri sunucuya gönderir.</li></ul><p><strong>Controller Layer MVC — C<br></strong>Kullanıcının gönderdiği HTTP isteklerini karşılar, servis katmanına yönlendirir:</p><ul><li>AuthController: Giriş / kayıt gibi işlemler için endpoint sağlar.</li><li>UserController: Kullanıcı işlemlerini yönetir, JWT kontrolü yapar.</li></ul><p><strong>View Layer MVC — V</strong><br>Spring Boot’ta ekran yok, ama client’a dönen veriler “View” görevi görür:</p><ul><li><strong>JSON Response</strong>: API’den dönen standart yanıtlar</li><li><strong>DTO’lar</strong>: Veri taşıma nesneleri (RegisterRequest, UserResponse gibi)</li><li><strong>Error Response</strong>: Hata durumunda dönen özel formatlı mesajlar</li></ul><p><strong>Service Layer</strong><br>İşin mantığı burada döner. Controller yönlendirir, işin tüm beyin gücü burada:</p><ul><li>AuthService: Kayıt ve giriş işlemlerinin asıl mantığı burada.</li><li>UserService: Kullanıcı işlemleri (güncelleme, getirme vb.) burada yazılır.</li><li>UserDetailsService: Spring Security’ye kullanıcı verisi sağlamak için kullanılır.</li></ul><p><strong>Repository Layer</strong><br>Veritabanı işlemlerini JPA ile kolayca yönettiğimiz katman:</p><ul><li>UserRepository: findByEmail, existsByUsername gibi işlemleri yapar.</li></ul><p><strong>Model Layer MVC — M</strong><br>Veritabanındaki tabloları temsil eden sınıflar:</p><ul><li>User: @Entity ile işaretlenmiş domain model</li><li>@Valid, @NotNull gibi anotasyonlarla veri doğrulama yapılır</li></ul><p><strong>Database<br></strong>Verileri sakladığımız yer. Bu projede H2 Database kullanıyoruz:</p><ul><li>Dosya tabanlı, hafif ve kullanımı kolay</li><li>./data/testdb konumunda users tablosunu tutacak</li></ul><p><strong>Security Layer</strong><br>Uygulamanın güvenlik katmanı. Spring Security kullanarak JWT kontrolü yaparız:</p><ul><li>JwtAuthenticationFilter: Her isteği kontrol eder, token geçerli mi bakar</li><li>JwtUtil: Token üretme ve çözme işlemleri</li><li>SecurityConfig: Hangi endpoint&#39;e kim erişebilir belirlenir</li></ul><p>Bu yapıyı kurduktan sonra artık kafamız çok daha net olacak:</p><blockquote><em>“Controller ne yapar, Service ne yapar, Repository ne yapar?” soruları cevapsız kalmayacak.</em></blockquote><p>Altta projenin paket yapısını görebilirsiniz. Android projelerindeki dosyalama yapısıyla benzerlik kurarak daha rahat anlayacağınızı düşünüyorum:</p><pre>📁 SpringBootProject/<br>├── 📁 src/main/kotlin/          ← Android&#39;deki kotlin/ klasörü gibi<br>│   └── 📁 org/oguzhanozgokce/springbootproject/<br>│       ├── 📁 controller/       ← Activity&#39;lerin backend karşılığı<br>│       ├── 📁 service/          ← Business logic (Android&#39;deki ViewModel gibi)<br>│       ├── 📁 model/            ← Data class&#39;larınız<br>│       ├── 📁 repository/       ← Database access (Room DAO gibi)<br>│       ├── 📁 dto/              ← API request/response modelleri<br>│       ├── 📁 config/           ← Manifest ayarları gibi<br>│       └── 📁 security/         ← Authentication logic<br>├── 📁 src/main/resources/       ← Android&#39;deki res/ klasörü gibi<br>│   ├── application.properties   ← gradle.properties benzeri<br>│   └── 📁 static/              ← Android&#39;deki assets/ gibi<br>└── build.gradle                 ← Tamamen aynı!</pre><h4>Haydi İlk Endpoint’imizi Yazalım</h4><p>Artık mimarimizi anladık ve paket yapımızı oluşturduk. Şimdi sırada en heyecanlı kısım var: <strong>Kodu yazmak!</strong></p><p><strong>AuthController Oluşturma<br></strong>Android’de MainActivity nasıl giriş noktasıysa, Spring Boot’ta Controller sınıfları API’nin giriş noktalarıdır. İlk Controller’ımızı yazalım:</p><pre>@RestController<br>@RequestMapping(&quot;/api/auth&quot;)<br>class AuthController(<br>    private val authService: AuthService<br>) {<br>    <br>    @PostMapping(&quot;/register&quot;)<br>    fun register(@Valid @RequestBody request: RegisterRequest): ResponseEntity&lt;AuthResponse&gt; {<br>        val response = authService.register(request)<br>        return ResponseEntity.ok(response)<br>    }<br>    <br>    @PostMapping(&quot;/login&quot;)  <br>    fun login(@Valid @RequestBody request: LoginRequest): ResponseEntity&lt;AuthResponse&gt; {<br>        val response = authService.login(request)<br>        return ResponseEntity.ok(response)<br>    }<br>}</pre><p><strong>DTO’lar Data Transfer Objects<br></strong>Android’de API çağrıları için model class’lar nasıl oluşturuyorsanız, Spring Boot’ta da aynı mantık:</p><pre>data class RegisterRequest(<br>    @field:NotBlank(message = &quot;Username is required&quot;)<br>    @field:Size(min = 3, max = 20)<br>    val username: String,<br><br>    @field:Email(message = &quot;Email should be valid&quot;)<br>    val email: String,<br><br>    @field:Size(min = 6, message = &quot;Password must be at least 6 characters&quot;)<br>    val password: String,<br><br>    @field:NotBlank(message = &quot;First name is required&quot;)<br>    val firstName: String,<br><br>    @field:NotBlank(message = &quot;Last name is required&quot;)<br>    val lastName: String<br>)</pre><pre>data class LoginRequest(<br>    @field:NotBlank(message = &quot;Username is required&quot;)<br>    val username: String,<br><br>    @field:NotBlank(message = &quot;Password is required&quot;)<br>    val password: String<br>)</pre><pre>data class AuthResponse(<br>    val token: String,<br>    val user: UserResponse<br>)<br><br>data class UserResponse(<br>    val id: Long,<br>    val username: String,<br>    val email: String,<br>    val firstName: String,<br>    val lastName: String<br>)</pre><p>Buraya kadar AuthController ve DTO’ları tamamladık. Sırada <strong>AuthService</strong>’i yazarak JWT üretme aşamasına geçmek var</p><pre>@Service<br>class AuthService(<br>    private val userService: UserService,<br>    private val jwtUtil: JwtUtil,<br>    private val authenticationManager: AuthenticationManager<br>) {<br><br>    fun register(registerRequest: RegisterRequest): AuthResponse {<br>        val userResponse = userService.registerUser(registerRequest)<br>        val user = userService.findByUsername(registerRequest.username)<br>            ?: throw IllegalStateException(&quot;User not found after registration&quot;)<br><br>        val token = jwtUtil.generateToken(user)<br><br>        return AuthResponse(<br>            token = token,<br>            user = userResponse<br>        )<br>    }<br>}<br></pre><p><strong>Uygulama Geneli Hata Yönetimi</strong></p><pre>@RestControllerAdvice<br>class GlobalExceptionHandler {<br><br>@ExceptionHandler(IllegalArgumentException::class)<br>    fun handleIllegalArgumentException(ex: IllegalArgumentException): ResponseEntity&lt;ApiResponse&lt;Any&gt;&gt; {}<br>...<br>}</pre><ul><li>@ExceptionHandler(IllegalArgumentException::class) → <strong>400 Bad Request</strong></li><li>@ExceptionHandler(BadCredentialsException::class) → <strong>401 Unauthorized</strong></li><li>@ExceptionHandler(Exception::class) → <strong>500 Internal Server Error</strong></li></ul><blockquote><strong><em>Android Karşılığı:</em></strong><em> </em><em>Result.Error veya </em><em>Resource.Error üzerinden her hataya özgü mesaj dönmek</em></blockquote><p>Kısaca: “try/catch” dağınıklığını Controller’lardan kaldırıyoruz; Spring bu sınıfı görünce hatayı otomatik yakalayıp biçimli JSON’a çeviriyor.</p><p><strong>JWT İşlemleri — Güvenlik Katmanı</strong></p><p><strong>JwtUtil</strong>: Token Üret, Doğrula, Süreyi Kontrol Et</p><pre>@Component<br>class JwtUtil {<br><br>    @Value(&quot;\${jwt.secret}&quot;)<br>    private lateinit var secret: String<br><br>    @Value(&quot;\${jwt.expiration}&quot;)<br>    private var expiration: Long = 0<br><br>    private val key: SecretKey by lazy { Keys.hmacShaKeyFor(secret.toByteArray()) }<br><br>    fun generateToken(userDetails: UserDetails): String {<br>        val claims = HashMap&lt;String, Any&gt;()<br>        return createToken(claims, userDetails.username)<br>    }<br><br>...<br><br>    fun validateToken(token: String, userDetails: UserDetails): Boolean {<br>        return try {<br>            val username = extractUsername(token)<br>            username == userDetails.username &amp;&amp; !isTokenExpired(token)<br>        } catch (e: Exception) {<br>            false<br>        }<br>}</pre><ul><li>generateToken(user)HS512 ile imzalanmış token döner.</li><li>extractUsername(token)Claims.getSubject() – token’daki kullanıcı adını çözer.</li><li>validateToken(token, userDetails)Kullanıcı adı eşleşiyor mu &amp; token süresi dolmuş mu?</li></ul><p><strong>Sonraki Adım: SecurityConfig &amp; Auth Filter</strong></p><pre>@Configuration<br>@EnableWebSecurity<br>@EnableMethodSecurity(prePostEnabled = true)<br>class SecurityConfig(<br>    private val jwtAuthenticationFilter: JwtAuthenticationFilter<br>) {<br><br>    @Bean<br>    fun passwordEncoder(): PasswordEncoder {return BCryptPasswordEncoder()}<br><br>    @Bean<br>    fun authenticationManager(authConfig: AuthenticationConfiguration): AuthenticationManager {<br>        return authConfig.authenticationManager<br>    }<br><br>    @Bean<br>    fun securityFilterChain(http: HttpSecurity): SecurityFilterChain {<br>        http<br>            .csrf { it.disable() }<br>            .sessionManagement { it.sessionCreationPolicy(SessionCreationPolicy.STATELESS) }<br>            .authorizeHttpRequests { auth -&gt;<br>                auth<br>                    .requestMatchers(&quot;/api/auth/**&quot;).permitAll()<br>                    .requestMatchers(&quot;/error&quot;).permitAll()<br>                    .anyRequest().authenticated()<br>            }<br>            .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter::class.java)<br>            .headers { headers -&gt;<br>            headers.frameOptions { frame -&gt; frame.disable() }<br>            }<br><br>        return http.build()<br>    }<br>}<br><br>@Component<br>class JwtAuthenticationFilter(<br>    private val jwtUtil: JwtUtil,<br>    private val userDetailsService: UserDetailsService<br>) : OncePerRequestFilter() {<br><br>    private val logger = LoggerFactory.getLogger(JwtAuthenticationFilter::class.java)<br><br>    @Throws(ServletException::class, IOException::class)<br>    override fun doFilterInternal(<br>        @NonNull request: HttpServletRequest,<br>        @NonNull response: HttpServletResponse,<br>        @NonNull filterChain: FilterChain<br>    ) { }<br>    private fun getJwtFromRequest(request: HttpServletRequest): String? {...}<br>    private fun authenticateUser(jwt: String, request: HttpServletRequest) {...}<br>    override fun shouldNotFilter(request: HttpServletRequest): Boolean {...}</pre><ul><li><strong>SecurityConfig</strong>: http.csrf().disable(), authorizeHttpRequests ile hangi endpoint’ler public/private tanımlanacak.</li><li><strong>JwtAuthenticationFilter</strong>: Gelen her istekte Authorization: Bearer &lt;token&gt; başlığını alıp SecurityContext’e yerleştirir.</li></ul><h4>Postman ile API’yi Test Edelim</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ITC44Y64A9bBwZmBU7MVbw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ypgHxmJuSo0In42LKM25eQ.png" /></figure><p>Token döndüğünü ve kullanıcı bilgilerini içeren başarılı bir yanıt aldığımızı görebilirsiniz. Bu token’ı artık diğer korumalı endpoint’lerde kullanabiliriz (Authorization: Bearer &lt;token&gt;)</p><p>Android tarafına geçmeden önce gradle ayarlarını da gösterip geçmek istiyorum.</p><pre># Proje Adı<br>spring.application.name=SpringBootProject<br><br># Uygulama Portu (default: 8080 → ben 8082 yaptım)<br>server.port=8082<br><br># H2 Veritabanı Ayarları<br>spring.datasource.url=jdbc:h2:file:./data/testdb<br>spring.datasource.driverClassName=org.h2.Driver<br>spring.datasource.username={db_name}<br>spring.datasource.password={db_password}<br>spring.jpa.database-platform=org.hibernate.dialect.H2Dialect<br><br># H2 Console (tarayıcıdan veritabanına erişmek için)<br>spring.h2.console.enabled=true<br>spring.h2.console.path=/h2-console<br>spring.h2.console.settings.web-allow-others=true<br><br># Hibernate Ayarları<br>spring.jpa.hibernate.ddl-auto=update<br>spring.jpa.show-sql=false</pre><ul><li>spring.datasource.urlH2 adlı gömülü bir veritabanı kullanıyoruz. Bu, SQLite gibi çalışır, dosya tabanlıdır.</li><li>ddl-auto=updateVeritabanı tablolarını entity’lere göre otomatik oluşturur/günceller.</li><li>h2.console.enabled=trueTarayıcıda localhost:8082/h2-console yazarak veritabanı arayüzüne ulaşabilirsiniz.</li></ul><h3>Hata Alırsanız…</h3><p>Yaygın karşılaşılan hatalardan bazıları:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B9fvvabnCdOa9Jhf07pxeA.png" /></figure><h3>Android Tarafında Network Katmanını Kuruyoruz</h3><p>Artık Spring Boot API’miz hazır ve çalışıyor. Şimdi sıra Android tarafından bu API’yi tüketmeye geldi. Retrofit ile API çağrıları yapacağız, JWT token yönetimi ekleyeceğiz.</p><p><em>Android projenizde şu yapı var:</em></p><pre>📁 app/src/main/java/com/oguzhanozgokce/bootmobilesecure/<br>├── 📁 data/<br>│   ├── 📁 model/          ← API response modelleri<br>│   ├── 📁 network/        ← Retrofit, interceptor&#39;lar<br>│   ├── 📁 repository/     ← Repository pattern<br>│   └── 📁 source/remote/  ← API service&#39;ler<br>├── 📁 domain/<br>│   ├── 📁 model/          ← Domain modelleri<br>│   └── 📁 repository/     ← Repository interface&#39;ler<br>├── 📁 di/                 ← Dependency Injection modülleri<br>│   ├── NetworkModule.kt<br>│   ├── RepositoryModule.kt<br>├── 📁 ui/<br>│   ├── 📁 home/           ← Home screen (zaten mevcut)<br>│   ├── 📁 login/          ← Login ekranı<br>│   └── 📁 register/       ← Register ekranı<br>└── 📁 common/             ← Utilities</pre><h4>NetworkModule</h4><pre>@Module<br>@InstallIn(SingletonComponent::class)<br>object NetworkModule {<br><br>    private const val BASE_URL = &quot;BASE_URL&quot;<br><br>    @Provides<br>    @Singleton<br>    fun provideOkHttpClient(<br>        authInterceptor: AuthInterceptor,<br>        loggingInterceptor: LoggingInterceptor<br>    ): OkHttpClient {<br>        return OkHttpClient.Builder()<br>            .connectTimeout(30, TimeUnit.SECONDS)<br>            .readTimeout(30, TimeUnit.SECONDS)<br>            .writeTimeout(30, TimeUnit.SECONDS)<br>            .addInterceptor(authInterceptor)<br>            .addInterceptor(loggingInterceptor)<br>            .build()<br>    }<br><br>    @Provides<br>    @Singleton<br>    fun provideRetrofit(okHttpClient: OkHttpClient): Retrofit {<br>        return Retrofit.Builder()<br>            .baseUrl(BASE_URL)<br>            .client(okHttpClient)<br>            .addConverterFactory(GsonConverterFactory.create())<br>            .build()<br>    }<br><br>    @Provides<br>    @Singleton<br>    fun provideAuthService(retrofit: Retrofit): AuthService {<br>        return retrofit.create(AuthService::class.java)<br>    }</pre><ul><li>OkHttpClient30 sn timeout + <strong>AuthInterceptor</strong> (token ekler) + <strong>LoggingInterceptor</strong> (debug’da loglar)</li><li>RetrofitGson converter + tek bir Retrofit instance’ı</li><li>AuthService &amp; UserServiceRetrofit arayüzlerimizi singleton olarak sağlar</li></ul><blockquote>💡 <strong>Bilgi:</strong> Emülatör localhost&#39;u tanımaz. Android emülatörü için 10.0.2.2, fiziksel cihazlar için bilgisayarınızın IP adresi (örn. 192.168.1.1) kullanılmalıdır.</blockquote><h4>Network Güvenliği için Ayar</h4><p>Android 9 (API 28) ve sonrası clear-text HTTP bağlantılarını engelliyor.<br> Bu yüzden aşağıdaki network_security_config.xml dosyasını oluşturup manifest&#39;e tanımlamalıyız.</p><pre>&lt;network-security-config&gt;<br>    &lt;domain-config cleartextTrafficPermitted=&quot;true&quot;&gt;<br>        &lt;domain includeSubdomains=&quot;true&quot;&gt;localhost&lt;/domain&gt;<br>        &lt;domain includeSubdomains=&quot;true&quot;&gt;127.0.0.1&lt;/domain&gt;<br>        &lt;domain includeSubdomains=&quot;true&quot;&gt;10.0.2.2&lt;/domain&gt;<br>        &lt;domain includeSubdomains=&quot;true&quot;&gt;192.168.1.1&lt;/domain&gt;<br>    &lt;/domain-config&gt;<br>&lt;/network-security-config&gt;<br><br>manifest;<br>&lt;application<br>    ...<br>    android:networkSecurityConfig=&quot;@xml/network_security_config&quot;&gt;</pre><p><em>Bu sayede uygulama HTTP üzerinden local backend’e sorunsuzca istek atabilir.</em></p><h4>AuthInterceptor — Her İstekte Token Ekle</h4><pre>@Singleton<br>class AuthInterceptor @Inject constructor(<br>    private val tokenManager: TokenManager<br>) : Interceptor {<br><br>    override fun intercept(chain: Interceptor.Chain): Response {<br>        ...<br>    }<br>}</pre><ul><li>Diğer tüm isteklere Authorization: Bearer &lt;token&gt; başlığı ekler.</li><li>Sunucu <strong>401</strong> dönerse token’ı temizler → kullanıcıyı login ekranına yönlendirebilirsiniz.</li></ul><blockquote><strong><em>Backend paraleli:</em></strong><em> </em><em>JwtAuthenticationFilter bizde ne yapıyorsa, burada onun mobil yansıması var</em></blockquote><h4>DTO’lar — Backend JSON’uyla %100 Uyum</h4><p>RegisterRequest, LoginRequest, AuthResponse, UserResponse → Hepsi sunucuda oluşturduğumuz DTO’ların birebir aynısı. Böylece:</p><ul><li>Yanıt doğrudan AuthResponse olarak gelir, token’a erişmek tek satır.</li></ul><h4>AuthService — Retrofit Arayüzü</h4><pre>interface AuthService {<br><br>    @POST(&quot;auth/register&quot;)<br>    suspend fun register(@Body request: RegisterRequest): Response&lt;ApiResponse&lt;AuthResponse&gt;&gt;<br><br>    @POST(&quot;auth/login&quot;)<br>    suspend fun login(@Body request: LoginRequest): Response&lt;ApiResponse&lt;AuthResponse&gt;&gt;<br>}</pre><p>Dönen yanıt tipi: Response&lt;ApiResponse&lt;AuthResponse&gt;&gt; – sunucudaki <strong>ApiResponse</strong> şemasını birebir yansıtıyoruz.</p><h4>Repository Katmanı — MainRepositoryImpl</h4><pre>@Singleton<br>class MainRepositoryImpl @Inject constructor(<br>    private val authService: AuthService,<br>    private val userService: UserService,<br>    private val tokenManager: TokenManager<br>) : MainRepository {<br><br>    override suspend fun login(loginRequest: LoginRequest): Result&lt;AuthResponse&gt; {<br>        return safeCall { authService.login(loginRequest) }<br>            .onSuccess { authResponse -&gt;<br>                tokenManager.saveToken(authResponse.token, authResponse.tokenType)<br>            }<br>    }<br>...<br>}</pre><ul><li>safeCall { ... } → ağı sarmalayan, hata yönetimini abstract eden bir helper (Android’de sık kullandığımız pattern).</li><li>Başarılı login/register sonrası tokenManager.saveToken(...) → SharedPreferences’e token + türünü yazar</li><li>UI katmanı (MVI/MVVM) sadece Result dinler, token detayını bilmez.</li></ul><h4>ViewModel — Ui Katmanı</h4><pre>@HiltViewModel<br>class LoginViewModel @Inject constructor(<br>    private val mainRepository: MainRepository<br>) : ViewModel(),<br>    MVI&lt;UiState, UiAction, UiEffect&gt; by mvi(UiState()) {<br><br>    override fun onAction(uiAction: UiAction) {<br>        viewModelScope.launch {<br>            when (uiAction) {<br>                is UiAction.UsernameChanged -&gt; updateUiState {<br>                    copy(username = uiAction.username, usernameError = null)<br>                }<br>                is UiAction.PasswordChanged -&gt; updateUiState {<br>                    copy(password = uiAction.password, passwordError = null)<br>                }<br>                UiAction.LoginClicked -&gt; handleLogin()<br>            }<br>        }<br>    }<br>    <br>    private fun handleLogin() = viewModelScope.launch {<br>        mainRepository.login(loginRequest)<br>            .onSuccess {<br>                updateUiState { copy(isLoading = false) }<br>                emitUiEffect(UiEffect.NavigateToHome)<br>            }<br>            .onFailure { throwable -&gt;<br>                updateUiState { copy(isLoading = false) }<br>                emitUiEffect(UiEffect.ShowError(throwable.getUserMessage()))<br>            }<br>    }<br>}</pre><p>LoginViewModel, UI ile iş mantığı arasındaki köprü görevini görüyor.<br> Butona tıkladığınızda (LoginClicked), onAction() fonksiyonu tetikleniyor ve bu da handleLogin() fonksiyonunu çağırıyor.</p><p>handleLogin() fonksiyonunda, repository üzerinden login isteği atılıyor.<br>Yanıt başarılıysa → kullanıcı Home ekranına yönlendiriliyor.<br>Hata varsa → kullanıcıya hata mesajı gösteriliyor (örneğin Snackbar ile).</p><p>Ayrıca updateUiState { ... } fonksiyonu sayesinde isLoading gibi UI durumları güncelleniyor, örneğin buton disable ediliyor veya progress gösteriliyor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WdsrgvCv3l-PLx4v-HNPRA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wdhcuuryZogWmaluNNUMww.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ALNuqsU59mTTjfHa2BcC_Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NigEG6ZZpV_wDOSIzhwBMA.png" /></figure><p>Gördüğünüz gibi hem backend tarafında güvenli login/register işlemlerini kurduk hem de Android uygulamasından bu servisleri başarıyla tükettik.</p><p>Artık şunları yapabiliyoruz:<br>- Kayıt ol → Backend’e yazılır<br>- Giriş yap → Token alınır, kullanıcı bilgisi gelir<br>- Token saklanır → Güvenli ekranlara erişim sağlanır</p><p>Bu yazıda Android geliştirici gözüyle backend dünyasına adım attık ve uçtan uca çalışan bir login/register sistemi kurduk. <br>Amacım, backend’e adım atmak isteyen mobil geliştiricilere pratiğe dayalı, sade ve anlaşılır bir yol haritası sunmaktı.</p><p>Umarım siz de kendi projelerinizde bu yapıyı ve daha iyilerini temel alarak ilerlersiniz.</p><h4>Proje Kodlarına Erişim</h4><p>Eğer projeyi kendi bilgisayarınızda çalıştırmak veya daha detaylı incelemek isterseniz, tüm kaynak kodlarına GitHub üzerinden ulaşabilirsiniz:</p><ul><li><strong>Backend (Spring Boot):</strong><br> <a href="https://github.com/oguzhanozgokce/SpringBootProject">https://github.com/oguzhanozgokce/SpringBootProject</a></li><li><strong>Android Uygulaması (Jetpack Compose):</strong><br> <a href="https://github.com/oguzhanozgokce/BootMobileSecure">https://github.com/oguzhanozgokce/BootMobileSecure</a></li></ul><blockquote><em>Projeyi forklayabilir, kendinize göre geliştirebilir veya yıldız bırakmayı düşünebilirsiniz ⭐</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bfeca8ce6208" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android’de MVI (Model-View-Intent) Mimarisi: Temelden Uygulamaya Kadar Her Şey]]></title>
            <link>https://ozgokceoguzhan.medium.com/androidde-mvi-model-view-intent-mimarisi-temelden-uygulamaya-kadar-her-%C5%9Fey-d784c4c3b988?source=rss-2331c975c5c5------2</link>
            <guid isPermaLink="false">https://medium.com/p/d784c4c3b988</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[mvi-architecture]]></category>
            <category><![CDATA[mvi]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android-development]]></category>
            <dc:creator><![CDATA[oguzhanozgokce]]></dc:creator>
            <pubDate>Sun, 27 Apr 2025 18:43:33 GMT</pubDate>
            <atom:updated>2025-04-27T18:43:33.135Z</atom:updated>
            <content:encoded><![CDATA[<p>Android dünyasında uygulamalar büyüdükçe, ekranlardaki karmaşa da beraberinde geldi. Bir yandan kullanıcının yaptığı her etkileşimi doğru şekilde yakalamak isterken, diğer yandan arayüzü her zaman doğru ve güncel tutmak artık hiç kolay değildi. Özellikle kullanıcıların hızlıca birden fazla işlem yapabildiği ekranlarda, bir anda <strong>state yönetimi</strong> büyük bir sorun haline geldi.</p><p>Üstelik Jetpack Compose’un gelişiyle birlikte artık ekranlar daha <strong>deklaratif</strong> (yani “benim ekranım böyle görünmeli” dediğimiz) bir yapıya büründü. Ama bu da bize şunu gösterdi:<br>State’leri doğru yönetemiyorsak, ekranlarımız kaotik bir hâl alabiliyor. İşte tam bu noktada, <strong>MVI (Model — View — Intent)</strong> mimarisi sahneye çıktı.<br>MVI’ın sunduğu <strong>tek yönlü veri akışı</strong> (unidirectional data flow) sayesinde artık bir ekranın:</p><ul><li>Hangi durumda olduğunu,</li><li>Kullanıcıdan hangi aksiyonların geldiğini,</li><li>Ve bu aksiyonların nasıl sonuçlandığını</li></ul><p>çok daha düzenli bir şekilde takip edebiliyoruz. Böylece her şey net bir sırayla ilerler, sürpriz yoktur. Debug yaparken ya da yeni özellik eklerken kafamız daha rahat olur.</p><h3>MVI Nedir?</h3><p>MVI, aslında oldukça basit bir fikre dayanıyor:<br><strong>Her kullanıcı aksiyonu, uygulamanın yeni bir duruma geçmesi için bir tetikleyici olmalıdır.</strong></p><p>Bu mantığı görselleştirmek için aşağıdaki şemaya göz atalım:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0XJlhUdK-cX8288kSwZQjQ.png" /></figure><p>Şemaya baktığımızda MVI mimarisinin temel bileşenlerini net bir şekilde görebiliyoruz:</p><ul><li><strong>User (Kullanıcı):</strong> Uygulama ile etkileşime geçer. Örneğin bir butona tıklar, bir listeyi kaydırır.</li><li><strong>Intent:</strong> Kullanıcının bu etkileşimi bir <em>Intent</em>’e (niyet/istek) dönüşür. Yani “şunu yapmak istiyorum” der.</li><li><strong>Model:</strong> Intent ViewModel’a veya başka bir katmana iletilir, gerekli iş kuralları çalıştırılır ve bir sonuç üretilir.</li><li><strong>View:</strong> Üretilen bu yeni durum (state) ekrana yansıtılır ve kullanıcıya gösterilir.</li></ul><h3>MVI Yapısı Android’de Nasıl Kullanılır?</h3><p>Teoriyi öğrendik, peki ya pratiğe döktüğümüzde bu yapı Android projelerinde nasıl işliyor? Aşağıdaki şema bize bu akışı adım adım gösteriyor:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bkQaqt_ZrkiCTehXsi38bg.png" /></figure><ul><li><strong>UI Layer</strong>: Kullanıcının ekranla doğrudan etkileşimde bulunduğu katman.</li><li><strong>MVI Core Layer</strong>: Verilerin işlendiği, business logic’in döndüğü ve UI state’inin oluşturulduğu katman</li></ul><p>Şimdi bu akışı parça parça açıklayalım:</p><h3>1- Kullanıcı Etkileşimi (UI Layer)</h3><p>Her şey kullanıcının bir aksiyonuyla başlar.<br>Örneğin Home ekranı açıldığında kategorilerin ve ürünlerin yüklenmesini isteriz veya kullanıcı bir ürünü favorilere eklemek ister.</p><p>Bunu yöneten ekranımız:</p><pre>@Composable<br>fun HomeScreen(<br>    uiState: UiState,<br>    uiEffect: Flow&lt;UiEffect&gt;,<br>    onAction: (UiAction) -&gt; Unit,<br>    homeNavActions: HomeNavActions,<br>) {<br>    val context = LocalContext.current<br>    val categoryItems = uiState.categoryFlow?.collectAsLazyPagingItems()<br><br>    // UI Effect&#39;leri dinliyoruz<br>    uiEffect.CollectWithLifecycle { effect -&gt;<br>        when (effect) {<br>            is UiEffect.ShowToast -&gt; context.showToast(effect.message)<br>        }<br>    }<br>    HomeContent(<br>        uiState = uiState,<br>        homeNavActions = homeNavActions,<br>        categoryItems = categoryItems,<br>        onAction = onAction<br>    )<br>}</pre><ul><li><strong>State</strong> değişimini dinleyip ekranı güncelliyoruz (uiState).</li><li><strong>Effect</strong> yakalayıp kullanıcıya feedback gösteriyoruz (uiEffect).</li></ul><h3>2- Intent (UiAction) Gönderimi</h3><p>Kullanıcı bir aksiyon yaparsa, bu olay bir <strong>UiAction</strong> olarak ViewModel’a gönderiliyor.</p><p>Örneğin bir ürünü favorilere eklemek istediğinde:</p><pre>onToggleFavorite = { onAction(UiAction.ToggleFavorite(it)) }</pre><p>Bu UiAction sealed class’ında şöyle tanımlı:</p><pre>sealed class UiAction {<br>    data object LoadGetUser : UiAction()<br>    data object FetchCategory : UiAction()<br>    data object FetchProduct : UiAction()<br>    data class ToggleFavorite(val productId: Int) : UiAction()<br>}</pre><p>Bu yapı sayesinde her aksiyon net bir şekilde ayrılmış oluyor.</p><h3>3- ViewModel’da Intent İşlenmesi</h3><p>Gönderilen Intent, ViewModel’ın onAction() fonksiyonunda karşılanıyor:</p><pre>override fun onAction(uiAction: UiAction) {<br>    when (uiAction) {<br>        is UiAction.LoadGetUser -&gt; loadGetUser()<br>        is UiAction.FetchCategory -&gt; fetchCategory()<br>        is UiAction.FetchProduct -&gt; fetchProduct()<br>        is UiAction.ToggleFavorite -&gt; toggleFavorite(uiAction.productId)<br>    }<br>}</pre><p>Her aksiyon ilgili fonksiyona yönlendirilir.<br> Bu sayede ViewModel’da <strong>aksiyonlar ve iş mantığı</strong> temiz bir şekilde ayrılır.</p><h3>4- UseCase Kullanımı (Business Logic)</h3><p>Her aksiyonda ilgili iş kuralı (business logic) çalıştırılır.<br> Örneğin kullanıcı favori butonuna bastıysa veya ürünleri çekicekse</p><pre>private fun toggleFavorite(productId: Int) {<br>    viewModelScope.launch {<br>        toggleFavoriteUseCase(productId)<br>            .onSuccess { response -&gt;<br>                updateProductFavoriteStatus(response.productId, response.isFavorite)<br>                if (response.isFavorite) {<br>                    val product = currentState.productList.find { it.id == response.productId }<br>                    product?.let {<br>                        analyticsManager.logProductAddedToFavorites(it.id)<br>                    }<br>                }<br>            }<br>            .onFailure {<br>                sendEffect(UiEffect.ShowToast(it))<br>            }<br>    }<br>}</pre><pre>private fun fetchProduct() {<br>        viewModelScope.launch {<br>            updateState { copy(isLoading = true) }<br>            getProductsUseCase().fold(<br>                onSuccess = { productList -&gt;<br>                    updateState {<br>                        copy(<br>                            productList = productList,<br>                            isLoading = false<br>                        )<br>                    }<br>                },<br>                onError = { error -&gt;<br>                    updateState { copy(error = error, isLoading = false) }<br>                    emitUiEffect(UiEffect.ShowToast(error))<br>                }<br>            )<br>        }<br>    }</pre><ul><li>Favori durumu başarılı güncellenirse, ürünün state’i güncellenir.</li><li>Hata oluşursa kullanıcıya bir UiEffect ile mesaj gösteririz.</li></ul><p>Bu yaklaşım sayesinde UI tarafı hep <strong>güncel ve güvenli</strong> olur.</p><h3>5- State Yönetimi</h3><p>Veri çekildiğinde veya bir işlem tamamlandığında, ekranın da buna uygun şekilde güncellenmesi gerekir. Bu yüzden ViewModel içerisinde bir <strong>StateFlow</strong> kullanarak UI durumunu (state) yönetiriz.</p><p><strong>Önce StateFlow yapısını tanımlarız:</strong></p><pre>private var _uiState: MutableStateFlow&lt;HomeContract.UiState&gt; =<br>    MutableStateFlow(HomeContract.UiState())<br>val uiState = _uiState.asStateFlow()</pre><ul><li>_uiState → İçeride değiştirilebilen, MutableStateFlow türünde bir state.</li><li>uiState → Dışarıdan sadece okunabilen, StateFlow türünde bir yapı.</li></ul><p><strong>State Güncellemesi Nasıl Yapılır?</strong></p><p>State’i değiştirmek istediğimizde doğrudan müdahale etmeyiz.<br>Bunun yerine kontrollü bir şekilde, update fonksiyonunu kullanırız:</p><pre>private fun updateUiState(block: HomeContract.UiState.() -&gt; HomeContract.UiState) {<br>    _uiState.update(block)<br>}</pre><p><strong>Bir Örnek Üzerinden Gösterelim:</strong></p><p>Örneğin bir API çağrısı başlatıldığında yüklenme durumunu göstermek için:</p><pre>updateUiState { copy(isLoading = true) }</pre><p>Veri başarıyla çekildiğinde, ürün listesi güncellenir ve loading kapatılır:</p><pre>updateUiState {<br>    copy(<br>        isLoading = false,<br>        productList = fetchedProductList<br>    )<br>}</pre><p>Burada dikkat ederseniz:</p><ul><li>Sadece değişmesi gereken alanları copy() fonksiyonu ile değiştiriyoruz.</li><li>Geri kalan tüm alanlar eski state üzerinden otomatik korunuyor.</li></ul><p>Bu yöntem, <strong>state mutasyonunu</strong> (doğrudan değiştirmeyi) engeller ve <strong>recomposition</strong> sürecinin doğru çalışmasını sağlar</p><h3>6- UI Effect (Tek Seferlik Olaylar)</h3><p>Her zaman sadece ekranın (UI) güncellenmesi yeterli olmaz.<br> Bazen kullanıcıya:</p><ul><li>Bir Toast mesajı göstermek,</li><li>Bir hata durumunda bilgi vermek,</li><li>Veya bir navigasyon işlemi yaptırmak</li></ul><p>gibi <strong>tek seferlik olaylar (one-time events)</strong> göndermemiz gerekir.</p><p>İşte bu senaryolar için <strong>UiEffect</strong> yapısını kullanırız.</p><p><strong>UI Effect Yapısının Tanımlanması</strong></p><p>Öncelikle ViewModel içinde bir Channel tanımlarız.<br>Bu Channel, <strong>tek seferlik olayları</strong> UI katmanına göndermek için kullanılır:</p><pre>private val _uiEffect by lazy { Channel&lt;HomeContract.UiEffect&gt;() }<br>val uiEffect: Flow&lt;HomeContract.UiEffect&gt; by lazy { _uiEffect.receiveAsFlow() }</pre><ul><li>_uiEffect → Olayları geçici olarak tutan Channel&#39;dır.</li><li>uiEffect → Channel’ı bir Flow haline getirir, böylece UI tarafı bu olayları kolayca dinleyebilir.</li></ul><p><strong>UiEffect Sınıfı</strong></p><p>Tek seferlik olayları modellemek için bir sealed class yapısı kullanırız.<br>Örneğin, kullanıcıya bir Toast mesajı göstermek istediğimizde:</p><pre>sealed class UiEffect {<br>    data class ShowToast(val message: String) : UiEffect()<br>}</pre><p><strong>UI Effect Nasıl Gönderilir?</strong></p><p>ViewModel içerisinde, bir olay tetiklemek istediğimizde emitUieffect() fonksiyonunu çağırırız:</p><pre>private suspend fun emitUiEffect(uiEffect: FavoriteContract.UiEffect) {<br>    _uiEffect.send(uiEffect)<br>}</pre><p><strong>Gönderme Örneği:</strong></p><p>Örneğin bir hata aldığımızda kullanıcıya mesaj göstermek için:</p><pre>emitUieffect(UiEffect.ShowToast(error))</pre><p><strong>UI Effect Nasıl Collect Edilir?</strong></p><p>Gönderilen UiEffect, UI katmanında CollectWithLifecycle gibi bir yapıyla dinlenir ve işlenir:</p><pre>uiEffect.CollectWithLifecycle { effect -&gt;<br>    when (effect) {<br>        is UiEffect.ShowToast -&gt; context.showToast(effect.message)<br>    }<br>}</pre><p>Böylece:</p><ul><li>Etkinlik sadece bir kere tetiklenir (yani Toast sürekli gösterilmez),</li><li>Ekran State’i ile event’ler birbirine karışmaz.</li></ul><h3>Özet Akış</h3><p>Android’de MVI yapısında veri akışı adım adım şöyle ilerler:</p><h4>Kullanıcı Etkileşimi (User -&gt; View)</h4><ul><li>Kullanıcı bir aksiyon gerçekleştirir. (Örneğin: Ürünü favorilere eklemek)</li><li>Bu etkileşim, ekranda (View) yakalanır.</li></ul><h4>2. Intent Gönderimi (View -&gt; UiAction -&gt; ViewModel)</h4><ul><li>Kullanıcının yaptığı işlem bir <strong>UiAction</strong> (Intent) nesnesine dönüştürülür.</li><li>onAction(UiAction) fonksiyonu çağrılarak ViewModel’a iletilir.</li></ul><h4>3. İş Mantığı İşlenir (ViewModel -&gt; UseCase)</h4><ul><li>ViewModel, gelen UiAction’a göre ilgili <strong>UseCase</strong>’i tetikler.</li><li>UseCase çalışır, gerekli veri kaynağı işlemleri yapılır (API çağrısı, veritabanı vs).</li></ul><h4>4. Sonuç Döner (UseCase -&gt; ViewModel)</h4><ul><li>UseCase başarılı ya da başarısız bir sonuç döndürür.</li><li>Başarı durumunda veri alınır, hata durumunda hata mesajı üretilir.</li></ul><h4>5. UI State Güncellenir (ViewModel -&gt; UiState)</h4><ul><li>Gelen başarı sonucu veya hata sonucuna göre <strong>UiState</strong> güncellenir.</li><li>Bu güncelleme StateFlow üzerinden yapılır (_uiState.update { }).</li></ul><h4>6. (Opsiyonel) UI Effect Üretilir (ViewModel -&gt; UiEffect)</h4><ul><li>Eğer kullanıcıya bir “tek seferlik olay” göstermek gerekiyorsa (örneğin bir Toast, SnackBar veya Navigation), ViewModel bir <strong>UiEffect</strong> üretir.</li><li>Effect’ler Channel üzerinden gönderilir (_uiEffect.send(effect)).</li></ul><h4>7. UI Katmanı Güncellenir (UiState/UiEffect -&gt; View)</h4><ul><li><strong>UiState</strong> değişimi ile Compose ekranı otomatik olarak yeniden çizilir (<strong>Recomposition</strong> gerçekleşir).</li><li><strong>UiEffect</strong> geldiğinde tek seferlik bir işlem yapılır (örn: Toast mesajı gösterilir).</li></ul><h4>8. Yeni Kullanıcı Etkileşimi (View -&gt; User)</h4><ul><li>Ekrandaki yeni durumu gören kullanıcı tekrar bir aksiyonda bulunabilir.</li><li>Döngü başa döner.</li></ul><p><strong><em>Veri Akışı Diyagramı</em></strong></p><pre>User → View → UiAction → ViewModel → UseCase → ViewModel<br>    → (State Güncelle) → UiState → View (Recomposition)<br>    → (Opsiyonel: Effect Gönder) → UiEffect → View (Tek Seferlik Olay)</pre><h4>Neden Bu Yapı Bu Kadar Güçlü?</h4><p><strong>· Tek Yönlü Veri Akışı:</strong> Her şey net bir sırayla akar. Hata ayıklamak kolaydır.</p><p><strong>· State ve Event Ayrımı:</strong> UI durumları (State) ile tek seferlik olaylar (Effect) birbirine karışmaz.</p><p><strong>· Test Edilebilirlik:</strong> Her adım (UiAction, UseCase, State) bağımsız test edilebilir.</p><p><strong>· Kolay Okunabilirlik ve Bakım:</strong> Özellikle büyük projelerde değişiklik yapmak daha güvenli olur.</p><p>Şimdi MVI’ın neden güçlü bir yapı sunduğunu gördük. Peki bu gücü gerçek projelerde koruyabilmek için nelere dikkat etmeliyiz? Gelin, MVI mimarisi için en iyi uygulamalara birlikte göz atalım.</p><h3>MVI’da Best Practices</h3><p>MVI mimarisi doğru kullanıldığında çok güçlü bir yapı sunar. Ancak doğru prensiplere uyulmazsa, yapının en büyük avantajları kaybolur.</p><p><strong>1- UiAction ve UiEffect Ayrı Olmalı</strong></p><p><strong><em>Neden</em>?</strong></p><ul><li><strong>UiAction</strong>: Kullanıcıdan gelen bir isteği temsil eder. (örn: ürün listele, ürünü favorilere ekle)</li><li><strong>UiEffect</strong>: Kullanıcıya gösterilecek tek seferlik olayları temsil eder. (örn: hata mesajı göster, ekrana yönlendir)</li></ul><p>Bu ayrım sayesinde:</p><ul><li>Ekran durumu (state) ile event’ler birbirine karışmaz.</li><li>Tekrarlayan hatalı Toast gösterimleri gibi sorunlar yaşanmaz.</li><li>Her Intent (UiAction) sadece bir iş başlatır; ekran ise State ile kontrol edilir.</li></ul><p><strong>2- State Mutlaka Immutable Olmalı</strong></p><p><strong><em>Neden?</em></strong></p><p>State her zaman copy edilerek güncellenmeli. Böylece Compose sadece değişen yerleri fark eder ve recomposition doğru çalışır.</p><p><strong>3-</strong> <strong>Tek Yönlü Veri Akışı Asla Bozulmamalı</strong></p><p><strong><em>Neden?</em></strong></p><p>MVI’ın en güçlü yanı <strong>unidirectional data flow</strong> sağlamasıdır.<br>Yani veri akışı hep kullanıcı → ViewModel → View yönünde olur.</p><p>Eğer View, kendi başına veri değiştirmeye kalkarsa (örneğin bir butona tıklayınca doğrudan değişken güncellemek), bu akış bozulur ve debug kabusu başlar.</p><p><strong>4- UiEffect Daima Channel veya SharedFlow</strong> <strong>Kullanılarak Gönderilmeli</strong></p><p><strong><em>Neden?</em></strong></p><p>State ile Effect farklı doğaya sahiptir:</p><p>· State sürekli gözlemlenir.</p><p>· Effect bir kere gerçekleşir.</p><p>Bu yüzden Channel veya SharedFlow gibi bir mekanizma ile efektleri yönetmek gerekir.</p><p><strong>5- ViewModel, Sadece Durumu Yönetmeli</strong></p><p>ViewModel’ın görevi:</p><p>· İşleri başlatmak (UseCase çağırmak),</p><p>· Gelen sonuçlara göre state veya effect üretmektir.</p><p>· ViewModel içinde doğrudan UI işlemleri (örn: Toast, Dialog gösterimi) yapılmamalıdır.</p><p>Bunlar sadece UiEffect ile yönlendirilmelidir.</p><p>Umarım bu yazı, MVI mimarisine olan yaklaşımınızı daha sağlam bir temele oturtmuştur. Siz de MVI kullanırken edindiğiniz deneyimleri veya karşılaştığınız zorlukları yorumlarda paylaşmayı unutmayın! <strong>Birbirimizden öğreneceğimiz çok şey var.</strong> ❤</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d784c4c3b988" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pre-Commit Hook’lar ile Kod Kalitesini Nasıl Arttırdık?]]></title>
            <link>https://ozgokceoguzhan.medium.com/pre-commit-hooklar-ile-kod-kalitesini-nas%C4%B1l-artt%C4%B1rd%C4%B1k-f0a705e118fa?source=rss-2331c975c5c5------2</link>
            <guid isPermaLink="false">https://medium.com/p/f0a705e118fa</guid>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[detekt]]></category>
            <category><![CDATA[developer]]></category>
            <dc:creator><![CDATA[oguzhanozgokce]]></dc:creator>
            <pubDate>Tue, 24 Dec 2024 16:27:17 GMT</pubDate>
            <atom:updated>2024-12-24T20:11:59.942Z</atom:updated>
            <content:encoded><![CDATA[<p>Kod kalitesi, yazılım projelerinin sürdürülebilirliği, okunabilirliği ve bakım kolaylığı açısından kritik bir öneme sahiptir. Takım çalışmasıyla yürütülen projelerde ise bu kaliteyi sürekli olarak güvence altına almak daha da zorlu hale gelir. İşte tam da bu noktada <strong>Detekt</strong> gibi statik kod analizi araçları devreye girer. Detekt, Kotlin projelerinde kod kalitesini artırmaya yönelik kurallar sunarak, hem bireysel hem de takım çalışmalarında tutarlılığı sağlar.</p><p>Bu yazıda, Detekt’i projeye nasıl entegre edebileceğiniz, kendi kurallarınızı nasıl tanımlayabileceğiniz ve pre-commit hook ile commit öncesinde Detekt’i otomatik çalıştırarak kod kalitesini nasıl sürdürülebilir hale getirebileceğiniz adım adım açıklanmıştır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/463/1*nqV3PswFHNNcG64X2xKyvQ.png" /></figure><h3>Detekt Nedir?</h3><p>Detekt, Kotlin projelerinde statik kod analizi yaparak kodunuzu iyileştirmenize yardımcı olan bir araçtır. Kodunuzu belirli kurallara göre analiz eder, hataları tespit eder ve bunları raporlar. Detekt, şu gibi avantajlar sağlar:</p><ul><li><strong>Kod okunabilirliğini artırır.</strong></li><li><strong>Kodun karmaşıklığını ölçer ve optimize edilmesini önerir.</strong></li><li><strong>Kod standardını takım üyeleri arasında tutarlı hale getirir.</strong></li><li><strong>Potansiyel hataları commit öncesinde yakalar.</strong></li></ul><h3>Detekt’in Gradle’a Eklenmesi</h3><p><strong>Version Catalog’a Detekt Eklemek: </strong>Eğer projenizde libs.versions.toml kullanıyorsanız, Detekt’i buradan tanımlayabilirsiniz. Bunun için libs.versions.toml dosyanıza aşağıdaki satırları ekleyin:</p><pre>detekt = &quot;1.23.6&quot;<br><br>[plugins]<br>detekt = { id = &quot;io.gitlab.arturbosch.detekt&quot;, version.ref = &quot;detekt&quot; }<br><br>[libraries]<br>detekt = { group = &quot;io.gitlab.arturbosch&quot;, name = &quot;detekt-formatting&quot;, version.ref = &quot;detekt&quot; }</pre><p>Sonrasında, modül seviyesindeki build.gradle.kts dosyasına ilgili plugin&#39;leri eklemeniz gerekir:</p><pre>plugins {<br>    alias(libs.plugins.detekt)<br>}<br><br>---<br><br>dependencies {<br>    detektPlugins(libs.detekt)<br>}</pre><p>Son olarak Detekt için gerekli yapılandırmaları detekt bloğu içinde tanımlayın:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/662/1*SPZc-mYmabNi_hjYzAZdGw.png" /></figure><h4>Yapılandırmaların Anlamı</h4><ul><li><strong>config.setFrom</strong>: Kullanılacak olan konfigürasyon dosyasını belirtir. Bu örnekte, projenin kök dizininde bulunan detektConfig.yml dosyası tanımlanmıştır.</li><li><strong>source.from</strong>: Analiz edilecek dosya veya dizinleri belirtir. Bu örnekte, src/main/kotlin dizini seçilerek Kotlin kaynak dosyalarının analiz edilmesi sağlanmıştır.</li><li><strong>parallel</strong>: Analizin paralel olarak çalıştırılmasını sağlar. Büyük projelerde analizi hızlandırmak için kullanışlıdır.</li><li><strong>autoCorrect</strong>: Kodun, tanımlanmış formatlama kurallarına göre otomatik olarak düzeltilmesini sağlar. Eğer bu özelliği aktif hale getirmek isterseniz, true olarak ayarlayabilirsiniz.</li><li><strong>buildUponDefaultConfig</strong>: Varsayılan Detekt konfigürasyonuna ek olarak, kendi belirlediğiniz kuralları da uygulamak isterseniz bu özelliği true olarak ayarlayabilirsiniz.</li></ul><blockquote>Detekt’in en güncel versiyonuna göz atmak ve projenize uygun olan sürümü belirlemek için aşağıdaki bağlantıyı kullanabilirsiniz: <a href="https://github.com/detekt/detekt"><strong>DETEK_VERSİON</strong></a></blockquote><p>Projenizde detekt’ in çalıştığını görmek içinse Android studio’ da terminali açıp bu kodu yazmanız yeterli olucaktır.</p><pre>./gradlew detekt</pre><h3>Detekt Konfigürasyon Dosyası (YAML)</h3><p>Detekt, bir <strong>YAML dosyası</strong> üzerinden özelleştirilebilir. Bu dosyada kod stiline, adlandırmaya, karmaşıklığa ve diğer kurallara ilişkin ayarları yapabilirsiniz. Örnekler vererek daha iyi anlamızını sağlayacağım.</p><h4>Formatting</h4><p>Kod stilinizin tutarlı olmasını sağlamak için kullanılan bir modül. Bu kurallar, ekibin tüm üyelerinin aynı kodlama stilini kullanmasını sağlar.</p><pre>formatting:<br>  NewLineAtEndOfFile: # Dosya sonunda yeni bir satırın olup olmadığını kontrol eder.<br>    active: true     <br>    autoCorrect: true <br><br>  NoWildcardImports:  # Wildcard importları (ör. import java.util.*) yasaklar.<br>    active: false     <br><br>  SpacingBetweenDeclarationsWithAnnotations: # Anotasyonlu bildirimler arasında uygun boşluk olup olmadığını kontrol eder.<br>    active: true     <br>    autoCorrect: true <br><br>  NoMultipleSpaces:   # Kod içinde birden fazla boşluk kullanımını kontrol eder.<br>    active: true      <br>    autoCorrect: true </pre><p>autoCorrect: true ile bu hatalar otomatik düzeltilebilir</p><h4>Exceptions</h4><p>Kapsamlı exception yönetimi yapmak istiyorsanız bu bölüm işinize yarar. Örneğin, çok genel exception sınıflarının yakalanmasını engelleyebilirsiniz.</p><pre>TooGenericExceptionCaught: # Çok genel exception sınıflarını yakalamayı önler<br>  active: true<br>  excludes: <br>    - &#39;**/data/repository/AuthRepositoryImpl.kt&#39; </pre><p>exludes: ile hariç tutmak istediğiniz dosyaları belirtebiliyorsunuz</p><h4>Complexity</h4><p>Kodun karmaşıklığını ölçen ve yönetmenize yardımcı olan kurallar. Fonksiyonlarınızın veya constructor’larınızın çok fazla parametre almasını engelleyerek daha temiz kod yazmanızı sağlar.</p><pre>LongParameterList: # Çok uzun parametre listelerini tespit eder<br>  active: true<br>  functionThreshold: 8<br>  constructorThreshold: 8</pre><p>Eğer bir fonksiyon 8’den fazla parametre alıyorsa, Detekt sizi uyarır. Bu threshold değerlerini ihtiyacınıza göre değiştirebilirsiniz.</p><h4>Naming</h4><p>Kodunuzdaki isimlendirme standartlarını belirlemenize olanak tanır. Bu, özellikle ekip içinde anlaşılır ve tutarlı bir kod yapısı oluşturmak için önemlidir.</p><pre>FunctionNaming: # Fonksiyon isimlendirme kurallarını belirler<br>  active: true<br>  ignoreAnnotated: [ &#39;Composable&#39; ]</pre><p>@Composable olarak işaretlenen fonksiyonlarda isimlendirme kurallarını es geçmek için bu ayarı kullanabilirsiniz.</p><h4>Style</h4><p>Kodunuzdaki genel stil kurallarını tanımlayabileceğiniz bir bölüm. Projenin okunabilirliğini artırır ve kodun daha düzenli görünmesini sağlar.</p><pre>style:<br>  MagicNumber:<br>    active: true<br>    excludes:<br>      - &#39;**/theme/**&#39;</pre><p>Projede theme doysasındaki MagicNumber hatalarını görmezden gelicektir.</p><h4>Comments</h4><p>Kod içerisindeki yorumların doğru ve tutarlı bir şekilde kullanılmasını sağlar.</p><pre>comments:<br>  CommentOverPrivateFunction: # Özel (private) bir fonksiyonun üzerinde gereksiz yorum olup olmadığını kontrol eder.<br>    active: true<br>  UndocumentedPublicClass: # Public sınıfların dokümante edilmesini zorunlu kılar.<br>    active: true</pre><h4>Potential Bugs</h4><p>Kodda potansiyel hataları önceden tespit etmek için kullanılan kurallar içerir. Özellikle mantık hatalarını ve kötü kodlama pratiklerini bulmaya odaklanır.</p><pre>potential-bugs:<br>  UnsafeCallOnNullableType: # Nullable bir değişken üzerinde güvenli olmayan işlemleri tespit eder (ör. !! kullanımı).<br>    active: true<br>  EqualsAlwaysReturnsTrueOrFalse: # equals metodunun her zaman true veya false döndürüp döndürmediğini kontrol eder.<br>    active: true</pre><h4>Performance</h4><p>Performans sorunlarını önlemek için belirli kodlama pratiklerini denetler.</p><pre>performance:<br>  UnnecessaryObjectCreation: # Gereksiz nesne oluşturulmasını tespit eder.<br>    active: true</pre><h4>Empty Blocks</h4><p>Kodunuzda gereksiz boş blokları bulur ve raporlar.</p><pre>empty-blocks:<br>  EmptyFunctionBlock: # Boş fonksiyon bloklarını kontrol eder.<br>    active: true<br>  EmptyCatchBlock: # Boş catch bloklarını tespit eder.<br>    active: true</pre><blockquote>İhtiyacınıza uygun birçok kullanışlı kural daha mevcut. Daha detaylı incelemek isterseniz, aşağıya bıraktığım bağlantıdan erişebilirsiniz: <a href="https://detekt.dev/">DETEK_RULES</a></blockquote><h3>Pre-Commit Hook ile Detekt Entegrasyonu</h3><p>Detekt’i commit sürecine entegre ederek, kodun commit öncesinde otomatik olarak analiz edilmesini sağlayabilirsiniz. Böylece, kod kalitesi kontrollerini gözden kaçırma ihtimali ortadan kalkar.</p><h4>Pre-Commit Hook Nedir?</h4><p>Pre-commit hook, Git tarafından sağlanan bir özelliktir ve her commit işleminden önce belirli komutların çalıştırılmasını sağlar. Bu sayede, commit sırasında kod analizi yaparak potansiyel hataları tespit edebilirsiniz.</p><h4>Pre-Commit Hook ile Detekt Nasıl Kullanılır?</h4><p><strong><em>1- Pre-Commit Dosyasını Bulma:</em><br></strong>Projenizin içinde bulunan git doyasına girip hook klasörünü açınca karşınıza bir çok doysa gelicektir. Başlangıçta pre-commit.sample olarak gözükücektir siz tekrardan isimlendirip pre-commit olarak değiştirebilirsiniz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/732/1*zurps-47xLmXmkjkGogUFQ.png" /></figure><p><strong><em>2- Pre-Commit Hook İçeriği</em></strong></p><p>Artık pre-commit dosyanızınızın içine girerek aşağıdaki kodu yapıştırmalısınız. Bu script, Detekt’in çalıştırılmasını sağlar ve Detekt’ten hata dönerse commit işlemini durdurur:</p><pre>#!/usr/bin/env bash<br>echo &quot;Running detekt check...&quot;<br>OUTPUT=&quot;/tmp/detekt-$(date +%s)&quot;<br>./gradlew detekt &gt; $OUTPUT<br>EXIT_CODE=$?<br>if [ $EXIT_CODE -ne 0 ]; then<br>  cat $OUTPUT<br>  rm $OUTPUT<br>  echo &quot;***********************************************&quot;<br>  echo &quot;                 detekt failed                 &quot;<br>  echo &quot; Please fix the above issues before committing &quot;<br>  echo &quot;***********************************************&quot;<br>  exit $EXIT_CODE<br>fi<br>rm $OUTPUT</pre><p><strong><em>3- Hook’u Aktif Hale Getirme</em></strong></p><p>En son olarak çalışmasını sağlamak için Android Studio girip terminale aşağıdaki kodu yapıştırıp çalışmasını sağlayabilirsiniz.</p><pre>chmod +x .git/hooks/pre-commit</pre><p><strong><em>Unutmayın:</em></strong><em> Pre-commit hook’lar yerel olarak ayarlanır ve </em><em>.git/hooks dizini versiyon kontrolüne dahil edilmez. Bu nedenle, takım arkadaşlarınızın da aynı işlemleri kendi yerel ortamlarında yapması gereklidir.</em></p><h3>Sonuç</h3><p>Kod kalitesini artırmak ve bu kaliteyi sürdürülebilir hale getirmek, bir yazılım projesinin başarıya ulaşmasında kritik bir rol oynar. Bu yazıda, <strong>Detekt</strong> ve <strong>pre-commit hook’larının</strong> birlikte nasıl etkili bir şekilde kullanılabileceğini detaylıca ele aldık.</p><p>Detekt, bireysel ya da ekip projelerinde kod standartlarını korumak için güçlü bir araçtır. Pre-commit hook’lar ise bu standartların her zaman uygulanmasını garanti altına alır. Bu kombinasyon sayesinde, sadece temiz bir kod tabanı oluşturmakla kalmaz, aynı zamanda ekip içi uyumu ve proje verimliliğini de artırabilirsiniz.</p><p>Unutmayın, <strong>kaliteli kod yazmak yalnızca bir alışkanlık değil, aynı zamanda profesyonel bir yazılım geliştirme pratiğidir.</strong> Projelerinizde bu araçları kullanarak daha tutarlı, daha güvenli ve daha okunabilir bir kod yapısı oluşturabilirsiniz.</p><p>Yazıda yalnızca Detekt’in nasıl aktif edileceğinden ve pre-commit süreçlerine entegrasyonundan bahsettim. Ancak, bunun ötesinde yapabileceğiniz pek çok şey daha mevcut:</p><ul><li><strong>SonarLint, Checkstyle, ESLint gibi araçlarla</strong> kodunuzu potansiyel hatalar ve kötü pratikler için tarayabilirsiniz.</li><li><strong>Minimum code coverage</strong> (örneğin, %80) zorunluluğu getirerek testlerinizi daha etkili hale getirebilirsiniz.</li><li><strong>Commit mesajlarını belirli bir şablona</strong> (ör. Conventional Commits) uygun yazdırabilir, kod incelemelerini daha verimli hale getirebilirsiniz.</li></ul><p>Ve bunlar gibi pek çok iyileştirme süreciyle kod kalitenizi bir üst seviyeye taşıyabilirsiniz.</p><p>Umarım bu içerik, projelerinizde kullanabileceğiniz faydalı bilgiler sunmuştur. Görüşlerinizi ve geri dönüşlerinizi paylaşmayı unutmayın. Bir sonraki Medium yazımda görüşmek üzere, şimdilik hoşça kalın ve kaliteli kodlamanın tadını çıkarın! 🎉</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f0a705e118fa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hilt & Dagger Annotations]]></title>
            <link>https://ozgokceoguzhan.medium.com/hilt-dagger-annotations-dc74c42bea4f?source=rss-2331c975c5c5------2</link>
            <guid isPermaLink="false">https://medium.com/p/dc74c42bea4f</guid>
            <category><![CDATA[androiddev]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android-hilt]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[oguzhanozgokce]]></dc:creator>
            <pubDate>Sat, 07 Dec 2024 16:49:42 GMT</pubDate>
            <atom:updated>2024-12-07T16:49:42.293Z</atom:updated>
            <content:encoded><![CDATA[<p>Merhabalar, bu yazımda sizlere Android uygulama geliştirmede Dependency Injection sürecini daha kolay ve etkili bir şekilde yönetmenize olanak tanıyan Hilt ve Dagger Annotations konusunu ele alacağım.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1tLHs1B05SVRs0p5LTfynQ.png" /></figure><h3>1- @HiltAndroidApp</h3><h4>Nedir ve Ne İşe Yarar?</h4><p>@HiltAndroidApp, Hilt&#39;in dependency injection (DI) sistemini uygulamanıza entegre etmek için kullanılan bir anotasyondur. Bu anotasyon, uygulamanın başlatılma aşamasında bir Dagger komponenti oluşturur ve yaşam döngüsü boyunca dependency graph&#39;ını yönetir.</p><p>Hilt, uygulama düzeyinde bağımlılıkları yönetmek için bir giriş noktası gerektirir. İşte @HiltAndroidApp bu giriş noktasıdır. Anotasyonun bulunduğu sınıf, genellikle Application sınıfından türetilir.</p><h4>Nerede Kullanılır?</h4><p>@HiltAndroidApp, genellikle uygulamanın başlatılmasını yöneten ve bağımlılıkların diğer sınıflara enjekte edilmesini sağlayan Application sınıfında kullanılır. Bu, uygulama düzeyinde bağımlılıkların merkezi bir yerden sağlanmasını kolaylaştırır.</p><pre>@HiltAndroidApp<br>class MyApplication : Application() { ... }</pre><h3>2- @AndroidEntryPoint</h3><h4>Nedir ve Ne İşe Yarar?</h4><p>@AndroidEntryPoint, Hilt&#39;in bağımlılıkları bir sınıfa enjekte edebilmesi için kullanılan bir anotasyondur. Bu anotasyon, bir sınıfın Hilt&#39;in dependency injection sistemine dahil edileceğini belirtir.</p><p>Eğer bir aktivite, fragment, servis, ya da başka bir Android bileşeni üzerinde bağımlılık enjeksiyonu yapmak istiyorsanız, bu anotasyonu kullanmanız gerekir.</p><h4>Nerede Kullanılır?</h4><ul><li><strong>Activity</strong>: Bir aktiviteye bağımlılık enjekte etmek için.</li><li><strong>Fragment</strong>: Fragment’ta bağımlılık enjeksiyonu yapmak için.</li><li><strong>Service</strong>: Servislerde bağımlılık kullanımı için.</li><li><strong>BroadcastReceiver ve View</strong>: Bu tür bileşenlerde de kullanılabilir.</li></ul><p>Hilt, her bir Android bileşeni için otomatik olarak bir Dagger komponenti oluşturur ve bağımlılık grafiğini bu bileşenler için hazır hale getirir.</p><pre>@AndroidEntryPoint<br>class MyActivity : AppCompatActivity() { ... }</pre><h3>3- @Inject</h3><p>@Inject, Hilt ve Dagger&#39;ın temel taşlarından biridir. Bu anotasyon, bir sınıfa bağımlılıkların nasıl sağlanacağını belirler. İki temel kullanım alanı vardır:</p><ol><li><strong>Constructor Injection:</strong></li></ol><ul><li>Constructor injection, bağımlılıklarınızı doğrudan sınıfın constructor’ı aracılığıyla enjekte etmenizi sağlar. Bu yöntem, bağımlılıkların zorunlu olduğu durumlar için idealdir.</li></ul><pre>class AnalyticsAdapter @Inject constructor(<br>private val service: AnalyticsService<br>) { ... }</pre><p>2) <strong>Field Injection</strong></p><ul><li>Bir sınıfta bağımlılıkları doğrudan alanlara enjekte etmek için @Inject kullanılabilir. Ancak bu kullanım genellikle @AndroidEntryPoint ile işaretlenmiş sınıflarda tercih edilir.</li></ul><pre>@AndroidEntryPoint<br>class MyActivity : AppCompatActivity() {<br>  @Inject lateinit var adapter: AnalyticsAdapter<br>  ...<br>}</pre><h3><strong>4- @HiltViewModel</strong></h3><h4>Nedir ve Ne İşe Yarar?</h4><p>@HiltViewModel, Hilt kullanarak ViewModel sınıflarına bağımlılık enjeksiyonu yapmak için kullanılan bir anotasyondur. Jetpack ViewModel&#39;lar genellikle Activity veya Fragment&#39;lere özgü verilere ve işlemlere sahip olur. @HiltViewModel sayesinde, bir ViewModel&#39;in bağımlılıkları Hilt tarafından yönetilir.</p><p>Bu anotasyon, bir ViewModel&#39;i Hilt’in dependency injection sistemine dahil eder ve onun yaşam döngüsünü ilgili Activity veya Fragment ile uyumlu hale getirir.</p><h4>Nerede Kullanılır?</h4><ul><li>Hilt ile çalışan ViewModel sınıflarında.</li><li>@AndroidEntryPoint ile işaretlenmiş bir Activity veya Fragment&#39;te kullanılabilir.</li></ul><pre>@HiltViewModel<br>class MyViewModel @Inject constructor(<br>  private val adapter: AnalyticsAdapter,<br>  private val state: SavedStateHandle<br>): ViewModel() { ... }</pre><h3>5- @Module</h3><h4>Nedir ve Ne İşe Yarar?</h4><p>@Module, Hilt veya Dagger&#39;a bağımlılıkların nasıl sağlanacağını öğreten bir yapı taşını tanımlar. İçinde, bağımlılıkları sağlayan yöntemler yer alır. Bu yöntemler, genellikle @Provides veya @Binds anotasyonları ile işaretlenir.</p><p>Bir @Module sınıfı, bağımlılıkları oluşturmak veya sağlamak için bir fabrikadır ve bu bağımlılıkların yaşam döngüsünü yöneten bir Hilt komponentine bağlıdır.</p><h4>Nerede Kullanılır?</h4><ul><li>Hilt’in bilmediği bir bağımlılığı manuel olarak tanımlamak için.</li><li>Harici kütüphaneler veya yapılandırma gerektiren nesneler (Retrofit, OkHttp, vb.) için.</li></ul><pre>@InstallIn(SingletonComponent::class)<br>@Module<br>class AnalyticsModule { ... }</pre><h3>6- @InstallIn</h3><h4>Nedir ve Ne İşe Yarar?</h4><p>@InstallIn, bir @Module veya @EntryPoint sınıfının Hilt&#39;in hangi komponentine dahil edileceğini belirtir. Bu anotasyon, bağımlılığın yaşam döngüsünü belirler ve Hilt&#39;e bu bağımlılığın hangi kapsamda (scope) sağlanacağını açıkça söyler.</p><p>Her @Module veya @EntryPoint, Hilt&#39;in bir bileşenine (örneğin SingletonComponent, ActivityComponent) bağlıdır ve @InstallIn bu bağlantıyı sağlar.</p><pre>@InstallIn(SingletonComponent::class)<br>@Module<br>class NetworkModule {<br><br>    @Provides<br>    fun provideRetrofit(): Retrofit {<br>        return Retrofit.Builder()<br>            .baseUrl(&quot;https://api.oguzhanozgokce.com&quot;)<br>            .build()<br>    }<br>}</pre><h4>Dikkat Edilmesi Gereken</h4><ul><li><strong>Her </strong>@Module<strong> sınıfı bir </strong>@InstallIn<strong> anotasyonu içermelidir.</strong><br>Aksi takdirde, hangi komponentle ilişkilendirileceğini Hilt anlayamaz.</li></ul><h3>7- @Provides ve @Binds</h3><h4>@Provides Nedir ve Ne İşe Yarar?</h4><p>@Provides, Hilt veya Dagger&#39;a bir bağımlılığın nasıl sağlanacağını açıklayan bir yöntem üzerinde kullanılır. Bu yöntem, bağımlılıkların manuel olarak oluşturulması ve Hilt&#39;in bağımlılık grafiğine eklenmesi gerektiği durumlar için idealdir.</p><p>Bazı durumlarda, Hilt bağımlılıkları otomatik olarak sağlayamaz (örneğin, bir kütüphane nesnesi veya özel yapılandırma gerektiren bir sınıf). Bu gibi durumlarda, @Provides ile bağımlılık tanımlanır ve Hilt&#39;e nasıl oluşturulacağı öğretilir. Ancak, @Provides bir bağımlılığı <strong>runtime</strong> sırasında oluşturduğu için performans açısından daha maliyetli olabilir.</p><h4>@Binds Nedir ve Ne İşe Yarar?</h4><p>@Binds, bir <strong>interface</strong> veya <strong>abstract class</strong> ile onun <strong>implementasyonu</strong> arasında bağlantı kurmak için kullanılır. Hilt’e, bir interface için hangi implementasyonun sağlanacağını öğretir.</p><p>@Binds, <strong>compile-time</strong> sırasında bağımlılığı sağlar ve @Provides&#39;a göre daha sade ve performanslıdır, çünkü nesneyi doğrudan bağlar. Ancak yalnızca <strong>abstract bir @Module</strong> sınıfında kullanılabilir.</p><h4>En Önemli Fark: Compile-Time vs Runtime</h4><ul><li><strong>@Provides:</strong> Bağımlılık <strong>runtime</strong> sırasında oluşturulur. Bu da performans açısından daha maliyetli olabilir.</li><li><strong>@Binds:</strong> Bağımlılık <strong>compile-time</strong> sırasında bağlanır, bu nedenle daha hızlı ve performanslıdır.</li></ul><pre>@InstallIn(SingletonComponent::class)<br>@Module<br>abstract class AnalyticsModule {<br><br>  @Binds<br>  abstract fun bindsAnalyticsService(<br>    analyticsServiceImpl: AnalyticsServiceImpl<br>  ): AnalyticsService<br>}</pre><h4>Ne Zaman Hangisini Kullanmalısınız?</h4><ul><li>Eğer bir interface ve onun implementasyonu varsa, @Binds tercih edilmelidir.</li><li>Eğer bir sınıf elle oluşturuluyor veya yapılandırma gerektiriyorsa, @Provides tercih edilmelidir.</li></ul><h3>9- Scope Annotations: @Singleton || @ActivityScoped</h3><h4>Nedir ve Ne İşe Yarar?</h4><p>Hilt’te <strong>Scope Annotations</strong>, bir bağımlılığın yaşam döngüsünü belirlemek için kullanılır. Hangi sınıfın ne kadar süreyle aynı örneği kullanacağını kontrol eder.</p><p>@Singleton:</p><ul><li>Tüm uygulama boyunca yalnızca <strong>bir adet</strong> örnek oluşturulur.</li><li>Uygulamanın yaşam döngüsü boyunca aynı örnek kullanılır.</li><li>Genellikle global, ağır veya yeniden oluşturulması gereksiz bağımlılıklar için kullanılır (örneğin, Retrofit, Database, SharedPreferences).</li></ul><p>@ActivityScoped:</p><ul><li>Her Activity için <strong>tek bir örnek</strong> oluşturulur.</li><li>Aktivite yeniden oluşturulduğunda, bağımlılık da yeniden sağlanır.</li><li>Aktiviteye özgü iş mantıklarını barındıran sınıflar için uygundur (örneğin, Activity&#39;ye özel bir cache veya adapter).</li></ul><pre>@Singleton<br>class AnalyticsAdapter @Inject constructor(<br>  private val service: AnalyticsService<br>) { ... }<br><br><br>@ActivityScoped<br>class SessionManager @Inject constructor() {<br>    fun getSessionData(): String {<br>        return &quot;Session Data&quot;<br>    }<br>}<br><br>@Module<br>@InstallIn(ActivityComponent::class)<br>object ActivityModule {<br><br>    @Provides<br>    @ActivityScoped<br>    fun provideSessionManager(): SessionManager {<br>        return SessionManager()<br>    }<br>}</pre><h3>10- Qualifiers for predefined Bindings: @ApplicationContext @ActivityContext</h3><h4>Nedir ve Ne İşe Yarar?</h4><p>Hilt, Context türündeki bağımlılıkları otomatik olarak enjekte eder. Ancak, uygulama düzeyi (ApplicationContext) ile aktivite düzeyi (ActivityContext) arasında ayrım yapmak gerektiğinde, bu <strong>Qualifier Annotations</strong> kullanılır. Bu sayede, aynı türdeki (Context) ancak farklı kapsam ve yaşam döngüsüne sahip bağımlılıklar birbirinden ayrılır.</p><h4>Kullanım Alanları:</h4><p><strong>@ApplicationContext</strong></p><ul><li>Uygulama düzeyindeki bağımlılıklar için.<br>Örnek: SharedPreferences, Room gibi uygulama boyunca kullanılacak nesneler.</li></ul><p><strong>@ActivityContext</strong></p><ul><li>Aktiviteye özgü bağımlılıklar için.<br>Örnek: Toast, Dialog, veya RecyclerView adapter gibi UI bileşenleri.</li></ul><pre>@Singleton<br>class AnalyticsAdapter @Inject constructor(<br>  @ApplicationContext val context: Context<br>  private val service: AnalyticsService<br>) { ... }<br><br>@Module<br>@InstallIn(ActivityComponent::class)<br>object ContextModule {<br><br>    @Provides<br>    fun provideToastMaker(@ActivityContext context: Context): ToastMaker {<br>        return ToastMaker(context)<br>    }<br>}<br><br>class ToastMaker(private val context: Context) {<br>    fun showToast(message: String) {<br>        Toast.makeText(context, message, Toast.LENGTH_SHORT).show()<br>    }<br>}</pre><h3>11- @EntryPoint</h3><h4>Nedir ve Ne İşe Yarar?</h4><p>@EntryPoint, Hilt bağımlılıklarını Hilt’in doğrudan desteklemediği sınıflara (<strong>ContentProvider</strong>, <strong>BroadcastReceiver</strong>, <strong>Service</strong>, vb.) enjekte etmek için kullanılır. Bu sınıflar Hilt&#39;in yaşam döngüsüne dahil olmadığı için @EntryPoint ve EntryPointAccessors kullanılarak bağımlılıklara erişim sağlanır.</p><h4>Nasıl Kullanılır?</h4><pre>class MyContentProvider(): ContentProvider {<br>@InstallIn(SingletonComponent::class)<br>@EntryPoint<br>interface MyContentProviderEntryPoint {<br>  fun analyticsService(): AnalyticsService<br>}<br><br>override fun query(...): Cursor {<br>  val appContext =<br>    context?.applicationContext<br>    ?: throw IllegalStateException()<br>  val entryPoint =<br>    EntryPointAccessors.fromApplication(<br>    appContext,<br>   MyContentProviderEntryPoint::class.java)<br>  val analyticsService =<br>    entryPoint.analyticsService()<br>  ...<br>  }<br>}</pre><p>Bu örnekte, MyContentProviderEntryPoint adlı bir interface, AnalyticsService bağımlılığına erişim sağlamak için tanımlanmıştır. Interface, @InstallIn(SingletonComponent::class) ile işaretlenerek bağımlılığın uygulama boyunca tek bir örnek olarak kullanılacağı belirtilmiştir.</p><p>query metodunda, context?.applicationContext kullanılarak uygulama düzeyi Context alınır ve EntryPointAccessors.fromApplication metodu ile AnalyticsService bağımlılığına erişilir. Böylece AnalyticsService, ContentProvider içinde kullanılabilir hale gelir. Bu yöntem, Hilt&#39;in desteklemediği bileşenlerde bağımlılıkları manuel olarak bağlamanızı sağlar.</p><p>Bu yazıda, Hilt ve Dagger’da sık kullanılan tüm anotasyonları detaylı bir şekilde ele aldık.</p><p>Eğer bu konuları daha detaylı bir şekilde incelemek veya resmi dokümantasyondan faydalanmak isterseniz, aşağıdaki bağlantılara göz atabilirsiniz:</p><ul><li><a href="https://developer.android.com/training/dependency-injection/hilt-cheatsheet?hl=tr">Hilt Cheatsheet</a></li><li><a href="https://developer.android.com/training/dependency-injection/hilt-android?hl=tr">Hilt ve Android Eğitimi</a></li></ul><p>Umarım bu yazı, Hilt ve Dagger konularında size yol gösterici olur. Bir sonraki yazıda görüşmek üzere!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dc74c42bea4f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>