Transaction question and jdbc question has been answered

Author: momedalhouma

pom.xml

@@ -75,7 +75,11 @@
             <artifactId>h2</artifactId>
             <version>1.4.197</version>
         </dependency>
-
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-orm</artifactId>
+            <version>5.1.5.RELEASE</version>
+        </dependency>
     </dependencies>
 
 </project>

src/main/java/data/question_001/SpringException.java renamed to src/main/java/data_transaction_jpa/question_001/SpringException.java

@@ -1,18 +1,18 @@
-package data.question_001;
+package data_transaction_jpa.question_001;
 
 
 /**
  *  What is the difference between checked and unchecked exceptions?
  * • Why does Spring prefer unchecked exceptions?
- * • What is the data access exception hierarchy?
+ * • What is the data_transaction_jpa access exception hierarchy?
  *
  *
  *
  *
  * Checked exception should be managed in a try catch block or should be declared on the method signature.
  * unchecked exception don't have this restriction.
  * For this reason Spring Framework prefer to use the unchecked exception.
- * All the exceptions in the data access hierarchy are unchecked.
+ * All the exceptions in the data_transaction_jpa access hierarchy are unchecked.
  * The purpose is to isolate the applications from particularity of vendor specification.
  *
  */

src/main/java/data/question_02/MyDataSource.java renamed to src/main/java/data_transaction_jpa/question_02/MyDataSource.java

@@ -1,8 +1,7 @@
-package data.question_02;
+package data_transaction_jpa.question_02;
 
 
 import ioc.commun.Person;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
@@ -20,7 +19,6 @@
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
 
 import javax.sql.DataSource;
-import java.sql.Date;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.time.LocalDate;
@@ -145,8 +143,8 @@ public DataSource secondDataSource (){
     public DataSource thirdDataSource (){
         final EmbeddedDatabase embeddedDatabase = new EmbeddedDatabaseBuilder()
                 .setType(EmbeddedDatabaseType.H2)
-                .addScripts("databaseconfig/ddl.script",//ddl data definition language define database schema
-                        "databaseconfig/dml.script")//dml data manipulation language CRUD operations
+                .addScripts("databaseconfig/ddl.script",//ddl data_transaction_jpa definition language define database schema
+                        "databaseconfig/dml.script")//dml data_transaction_jpa manipulation language CRUD operations
                 .build();
         return embeddedDatabase;
 

src/main/java/data/question_03_04_05_06_07/MyJdbcTemplate.java renamed to src/main/java/data_transaction_jpa/question_03_04_05_06_07/MyJdbcTemplate.java

@@ -1,4 +1,4 @@
-package data.question_03_04_05_06_07;
+package data_transaction_jpa.question_03_04_05_06_07;
 
 import org.springframework.jdbc.core.JdbcTemplate;
 
@@ -18,9 +18,9 @@
  * 1-Template design pattern define some steps which are executed in order, the super type define this order,
  * the subclasses implement only some predefined steps.
  * 2-
- *   a- RowMapper<Object>: allows to handle rows in a result set row by row {@link data.question_02.MyDataSource#rowMapper(JdbcTemplate)}.
+ *   a- RowMapper<Object>: allows to handle rows in a result set row by row {@link data_transaction_jpa.question_02.MyDataSource#rowMapper(JdbcTemplate)}.
  *   b-resultSetExtractor<List<Object>>:
- *                         allows to process the entire result set {@link data.question_02.MyDataSource#resultSetExtractor(JdbcTemplate)}.
+ *                         allows to process the entire result set {@link data_transaction_jpa.question_02.MyDataSource#resultSetExtractor(JdbcTemplate)}.
  *   c-@todo example to make for the RowCallbackHandler
  * * 3-yes
  * 4-Jdbc template release the connection after every request. jdbctemplate is trade safe
@@ -52,9 +52,9 @@ public final void templateMethod(){
         destroy();
     }
     public final void init() {}
-    public void method1() {throw new RuntimeException("the method1 should be implemented");}
-    public void method2() {throw new RuntimeException("the method2 should be implemented");}
-    public void method3() {throw new RuntimeException("the method3 should be implemented");}
+    public void method1() {throw new RuntimeException("the method1 should be implemented by the subclasses");}
+    public void method2() {throw new RuntimeException("the method2 should be implemented by the subclasses");}
+    public void method3() {throw new RuntimeException("the method3 should be implemented by the subclasses");}
     public final void destroy() {}
 
 

src/main/java/data/question_03_04_05_06_07/SqlQuery.java renamed to src/main/java/data_transaction_jpa/question_03_04_05_06_07/SqlQuery.java

@@ -1,7 +1,7 @@
-package data.question_03_04_05_06_07;
+package data_transaction_jpa.question_03_04_05_06_07;
 
 
-import data.question_02.MyDataSource;
+import data_transaction_jpa.question_02.MyDataSource;
 import ioc.commun.Person;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;

src/main/java/data_transaction_jpa/question_08_09_10_11/EnablingTransaction.java

@@ -0,0 +1,72 @@
+package data_transaction_jpa.question_08_09_10_11;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jdbc.datasource.DataSourceTransactionManager;
+import org.springframework.jdbc.datasource.DriverManagerDataSource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.sql.DataSource;
+
+/**
+ *
+ * How are you going to define transaction in Spring?
+ * What does @Transactional do?
+ * What is the PlatformTransactionManager?
+ *
+ * A transaction Manager {@link  PlatformTransactionManager}, should exists on the classpath to enable transaction management.
+ * enable transaction by annotating one configuration class {@link EnableTransactionManagement}.
+ * @Transactional on classes or method that should run in transaction.
+ *
+ *
+ * Is the JDBC template able to participate in an existing
+ * transaction?
+ * This is accomplished by wrapping the DataSource using a TransactionAwareDataSourceProxy.
+ */
+public class EnablingTransaction {
+
+}
+
+@Service
+@Transactional
+class Myservice{
+    public void methodOne(int a){ }
+
+    //overriding the class annotation
+    @Transactional(isolation = Isolation.SERIALIZABLE, propagation = Propagation.MANDATORY)
+    public void methodTwo(int a){ }
+}
+
+
+
+@EnableTransactionManagement
+@Configuration
+class MyConfiguration{
+
+    /**
+     * defining a transaction manager
+     * @return
+     */
+    @Bean
+    public PlatformTransactionManager transactionManager (){
+        return new DataSourceTransactionManager(datasource());
+    }
+
+    /**
+     * defining a datasource
+     * @return
+     */
+    public DataSource datasource(){
+        DriverManagerDataSource dataSource = new DriverManagerDataSource();
+        dataSource.setUsername("");
+        return dataSource;
+    }
+
+
+
+
+}

src/main/java/data_transaction_jpa/question_08_09_10_11/MyTransaction.java

@@ -0,0 +1,21 @@
+package data_transaction_jpa.question_08_09_10_11;
+
+
+/**
+ *
+ * -What is a transaction?
+ *      A transaction in a unit of work that should either fully executed or fully canceled.
+ *      transaction principals are: ACID.
+ *       A: Atomicity, the same as the definition of the transaction.
+ *       C: Consistency, guarantee that evey database constraint will not be violated.
+ *       I: Isolation, isolation level that defines how more than one transactions are handled win parallel.
+ *       D: Durability, guarantee that when the transaction commit, the change are also stored into the database.
+ * -What is the difference between a local and a global transaction?
+ *      Local transaction: when we deel with inly one single transactional resource.
+ *      Global transaction: more than one transactional resource, handled by the app-server.
+ *
+ *   Is a transaction a cross cutting concern? YEs
+ *   How is it implemented by Spring? implemented using AOP Spring framework
+ *
+ */
+public class MyTransaction {}

src/main/java/data_transaction_jpa/question_12_13/EnablingTransactionManagement.java

@@ -0,0 +1,11 @@
+package data_transaction_jpa.question_12_13;
+
+
+/**
+ * What is @EnableTransactionManagement for?
+ * Enable to use @Transactional, One configuration class should be annotated.
+ *
+ *
+ */
+public class EnablingTransactionManagement {
+}

src/main/java/data_transaction_jpa/question_12_13/IsolationLevel.java

@@ -0,0 +1,36 @@
+package data_transaction_jpa.question_12_13;
+import org.springframework.transaction.annotation.Isolation;
+
+/**
+ * Problems we can get when two or more transactions are executing in parallel on the same data_transaction_jpa.
+ * {@link IsolationLevel.READ_UNCOMMITTED} is the slowest isolation level, T1 can Read uncommitted data_transaction_jpa from T2.
+ * This Isolation level can produces Dirty Read problem:
+ * On one cell for example, T1 read 10, T2 write 15,T1 read 15, T2 rollback, T1 get bad result.
+ * T1---10---------25---
+ * T2---10-----15----10-
+ *
+ * Dirty read occurs when T1 read data_transaction_jpa that was not yet committed by another Transaction.
+ * To solve this problem we should use {@link IsolationLevel.READ_COMMITTED}
+ *
+ * With {@link IsolationLevel.READ_COMMITTED}, non-repeatable read problem can be produced.
+ * T1---10---------25---
+ * T2--------15---------15
+ * On one cell for example, T1 read 10, T2 write 15, T1 in a second time read the same cell, as it was updated
+ *   by T2, T1 add 10, the value now is 25(bad result).
+ *
+ *
+ * With {@link IsolationLevel.REPEATABLE_READ}, phantom read(read-insertion problem)  problem can be produced.
+ *  T1---1---------2---
+ *  T2--------2--------
+ *  Suppose we have a table person(name, age)
+ *  For example, T1 with a query operation(get person.name where person.age>10), suppose also that in T1 we get one row as a response.
+ *  suppose now that T2 insert a new row[person('zaki', 30)] and commit. T1 in the second read operation will get 2 rows as a response.
+ *  The problem here is maybe In the operation In T1, we are performing an algorithm and we should have the same value of te read operation.
+ *  To solve this problem we should use {@link Isolation.Isolation.SERIALIZABLE}. This isolation guarantee that for example, every person with person.age>10
+ *  can not be read or written by another transaction.
+ *
+ * {@link https://www.byteslounge.com/tutorials/spring-transaction-isolation-tutorial}
+ *
+ */
+public class IsolationLevel {
+}

src/main/java/data_transaction_jpa/question_12_13/images/dirty_read.png

@@ -0,0 +1,16 @@
+package data_transaction_jpa.question_14_15_16_17_18_19;
+
+/**
+ *
+ *
+ * What is the default rollback policy in a JUnit test, when you use the
+ * @RunWith(SpringJUnit4ClassRunner.class) in JUnit 4 or
+ * @ExtendWith(SpringExtension.class) in JUnit 5, and annotate your @Test annotated
+ * method with @Transactional?
+ *
+ * Rollback after every test executed in a transactional mode, but we can change this default behaviour,
+ *
+ *
+ */
+public class TestingWithTransactionalMode {
+}

src/main/java/data_transaction_jpa/question_12_13/images/non_repeatable_read.png

@@ -0,0 +1,52 @@
+package data_transaction_jpa.question_14_15_16_17_18_19;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ *
+ *  1-What does transaction propagation mean?
+ *   Behaviour of a transaction in relation to another transaction, there are 7 propagation types:
+ *   T1
+ *   a(){
+ *       T2
+ *       b();
+ *   }
+ *   {@link Propagation#REQUIRED} //default in Spring
+ *      T2 will use T1 if T1 exists, will create a new Transaction otherwise.
+ *   {@link Propagation#REQUIRES_NEW}
+ *      every time, T2 will crete a new transaction.
+ *   {@link Propagation#NESTED}
+ *      T2 will use T1 if T1 exists, will create a new Transaction otherwise. If T2 rollback, T1 will rollback to.
+ *   {@link Propagation#SUPPORTS}
+ *      use T1 if it exists, do nothing otherwise
+ *   {@link Propagation#NOT_SUPPORTED}
+ *       suspend T1 if it exists, do nothing otherwise
+ *   {@link Propagation#NEVER}
+ *       throw an exception if T1 exist, do nothing otherwise
+ *   {@link Propagation#MANDATORY}
+ *       throw an exception if T1 doesn't exist, use T1 otherwise
+ *
+ *  2-What happens if one @Transactional annotated method is calling another @Transactional annotated method on the same object instance?
+ *    the inner method will not run on a transactional mode.
+ *  3-Where can the @Transactional annotation be used? What is a typical usage if you put in class level?
+ *  4-What does declarative transaction management mean?
+ *      Class, method level. method override class level. All method in a annotated class level will be automatically annotated.
+ *  5-What is the default rollback policy? How can you override it?
+ *     rollback whenever an unchecked exception (RuntimeException or Error)is thrown from a method.
+ *     thrown in this scenario means that it was not cached by a try block catch in the method.
+ *  6- rollback policy overridden by :
+ *     rollBackFor
+ *     rollBackForClassName
+ *     noRollBackFor
+ *     noRollBackForClassName
+ *
+ *
+ */
+public class TransactionPropagation {
+
+
+
+
+}

src/main/java/data_transaction_jpa/question_12_13/images/phantom_read.png

@@ -0,0 +1,12 @@
+package data_transaction_jpa.question_20_21_22_23_24;
+
+
+/**
+ * Why is the term "unit of work" so important and why does JDBC AutoCommit violate this pattern?
+ *  unit of work--> atomicity.
+ *  Jdbc AutoCommit violate this pattern, because after each query,
+ *  a commit will be executed, so if we have many query we will not have the atomicity property.
+ *
+ */
+public class JDBCAutoCommitMode {
+}