La notion de printemps
La gestion entre les classes et les classes aide les développeurs à créer des objets et à gérer les relations entre les objets.
technologie de noyau de ressort ioc, aop Il peut réaliser le découplage entre les modules et les classes.
La première fonction principale de Spring IOC
IOC (Inversion of Control): L'inversion du contrôle est une théorie, un concept et une pensée.
Description : la création, l'affectation et la gestion des objets sont toutes implémentées par le conteneur en dehors du code, c'est-à-dire que la création des objets est complétée par d'autres ressources externes.
Contrôle : créer des objets, attribuer des attributs aux objets et gérer les relations entre les objets.
Inversion : transférez l'autorité de gestion du développeur et de création d'objet d'origine vers l'implémentation du conteneur en dehors du code. Les objets sont gérés par le conteneur au lieu du développeur. Créez un objet et
attribuez des valeurs aux propriétés.
Rotation vers l'avant : le développeur utilise le nouveau constructeur pour créer des objets dans le code, et le développeur gère activement les objets.
public static void main(String args[]){
Student student = new Student(); // 在代码中， 创建对象。--正转。
}
Conteneur : C'est un logiciel serveur, un framework (ressort)
Pourquoi utiliser ioc : Le but est de réduire les changements de code et d'obtenir différentes fonctions. Réaliser le découplage.
java中创建对象有哪些方式：
1. 构造方法 ， new Student（）
2. 反射
3. 序列化
4. 克隆
5. ioc ：容器创建对象
6. 动态代理
ioc的体现：
servlet 1： 创建类继承HttpServelt
2: 在web.xml 注册servlet ， 使用<servlet-name> myservlet </servlet-name>
<servelt-class>com.bjpwernode.controller.MyServlet1</servlet-class>
3. 没有创建 Servlet对象， 没有 MyServlet myservlet = new MyServlet()
4. Servlet 是Tomcat服务器它能你创建的。 Tomcat也称为容器
Tomcat作为容器：里面存放的有Servlet对象， Listener ， Filter对象
Réalisation technique du COI :
DI est l'implémentation technique de ioc
DI (Dependency Injection): Dependency Injection, il vous suffit de fournir le nom de l'objet à utiliser dans le programme, quant à la manière dont l'objet est créé,
attribué et recherché dans le conteneur, il est implémenté à l'intérieur du conteneur.
Spring utilise di pour implémenter la fonction de ioc, et la couche inférieure de spring crée des objets en utilisant le mécanisme de réflexion.
Spring est un conteneur qui gère les objets et attribue des valeurs aux propriétés.La couche inférieure est des objets de création de réflexion
。
spring-conetxt et spring-webmvc sont deux modules spring-context dans spring : il est pour la fonction ioc et crée des objets.
spring-webmvc est utilisé pour le développement Web et est une mise à niveau de servlet.
La fonction de création d'objets dans spring-context est également utilisée dans spring-webmvc.
junit : test unitaire, une bibliothèque de classes d'outils, utilisée pour les méthodes de test.
Unité : la méthode est spécifiée. Il existe de nombreuses méthodes dans une classe, et une méthode est appelée une unité.
Utilisez le test unitaire
1. Besoin d'ajouter la dépendance junit.
juint
juint
4.11
test
2. Créez une classe pour tester : la classe appelée la
classe de test est créée dans le répertoire src/test/java
3. Créer une méthode de test
1）public 方法
2）没有返回值 void
3）方法名称自定义，建议名称是test + 你要测试方法名称
4）方法没有参数
5）方法的上面加入 @Test ,这样的方法是可以单独执行的。 不用使用main方法。
- Avantages multiples de la configuration
1. La taille de chaque fichier est beaucoup plus petite qu'un seul fichier. Haute efficacité
2. Évitez les conflits causés par la concurrence entre plusieurs personnes.
Si votre projet comporte plusieurs modules (fonctions liées ensemble), un fichier de configuration par module.
Un fichier de configuration pour le module de présence des élèves, Zhang San
Un fichier de configuration pour les performances des élèves, Li Si
Comment distribuer plusieurs fichiers :
- Selon le module fonction, un fichier de configuration par module
- Selon la fonction de la classe, il existe un fichier de configuration de fichier pour la configuration liée à la base de données, un fichier de configuration pour la fonction de transaction, un fichier de configuration pour la fonction de service, etc.
2. Di basé sur les annotations : création complète d'objets Java et attribution d'attributs via des annotations.
Étapes pour utiliser les annotations :
1. Ajoutez la dépendance spring-context de maven, lorsque vous ajoutez spring-context, ajoutez indirectement la dépendance spring-aop.
L'utilisation d'annotations doit utiliser des dépendances spring-aop
2.在类中加入spring的注解（多个不同功能的注解）
3.在spring的配置文件中，加入一个组件扫描器的标签，说明注解在你的项目中的位置
Notes pour l'apprentissage :
1.@Composant
2.@Respotory
3.@Service
4.@Controller
5.@Value
6.@Autowired
7.@Resource
Demande de traitement de l'utilisateur :
formulaire utilisateur, nom du paramètre, âge-----Servlet (nom de la demande de réception, âge)—Classe de service (nom de traitement, opération d'âge)—classe dao (accès à la base de données)—mysql
================================================= == =============================================== =
Chapitre 3 aop
1. Méthode de mise en œuvre du proxy dynamique
: proxy dynamique jdk, utilisez Proxy, Method, InvocaitonHanderl dans jdk pour créer des objets proxy.
le proxy dynamique jdk nécessite que la classe cible implémente l'interface
proxy dynamique cglib : une bibliothèque d'outils tiers pour créer des objets proxy, le principe est l'héritage. Créez une sous-classe en héritant de la classe cible.
La sous-classe est l'objet proxy. Il est nécessaire que la classe cible ne puisse pas être finale et que la méthode ne puisse pas être finale
2. Fonctions du proxy dynamique :
1) Ajouter des fonctions sans modifier le code source de la classe cible.
2) Réduisez la duplication de code
3) Concentrez-vous sur le code de la logique métier
4) Découplage, afin que vos fonctions métier soient séparées des journaux, des fonctions transactionnelles non métier.
3. Aop: programmation orientée aspect, basée sur un proxy dynamique, vous pouvez utiliser jdk, cglib deux méthodes de proxy.
Aop est la normalisation du proxy dynamique. Les étapes et les méthodes de mise en œuvre du proxy dynamique sont définies,
afin que les développeurs puissent utiliser le proxy dynamique de manière unifiée.
- AOP (Aspect Orient Programming) Aspect Oriented Programming
Aspect : Aspect, la fonction ajoutée à votre classe cible est l'aspect. Comme les journaux utilisés ci-dessus, les transactions sont des aspects.
Caractéristiques des aspects : Généralement, ce sont des méthodes non commerciales et utilisées de manière indépendante.
Orient : face, face.
Programmation : programmation
oop : programmation orientée objet
Comment comprendre la programmation orientée aspect ?
1) Il est nécessaire de connaître l'aspect lors de l'analyse de la fonction du projet.
2) Aménager raisonnablement le temps d'exécution de l'aspect (avant la méthode cible ou après la méthode cible)
3) Position d'exécution raisonnable de l'aspect sécurité, dans quelle classe, quelle méthode ajoute des fonctions améliorées
Terminologie :
1) Aspect : Aspect, qui signifie une fonction améliorée, est un ensemble de codes pour compléter une certaine fonction. Les fonctions non commerciales,
les fonctions d'aspect communes incluent les journaux, les transactions, les statistiques, la vérification des paramètres et la vérification de l'autorité.
2) JoinPoint : le point de connexion, où la méthode commerciale et l'aspect sont connectés. Pour les méthodes commerciales d'une certaine classe
3) Pointcut : le point d'entrée fait référence à une collection de plusieurs méthodes de point de connexion. Méthodes multiples
4) Objet cible : Ajouter une fonction à la méthode de quelle classe, cette classe est l'objet cible
5) Conseil : notification, la notification indique le temps d'exécution de la fonction d'aspect.
说一个切面有三个关键的要素：
1）切面的功能代码，切面干什么
2）切面的执行位置，使用Pointcut表示切面执行的位置
3）切面的执行时间，使用Advice表示时间，在目标方法之前，还是目标方法之后。
5. Implémentation d' aop Aop est une spécification, une standardisation dynamique, un cadre
standard d'implémentation de la technologie aop : 1. spring : spring implémente la spécification aop en interne et peut effectuer le travail aop. Spring utilise principalement AOP dans le traitement des transactions. L'implémentation aop de Spring est rarement utilisée dans le développement de nos projets. Parce que l'aop du printemps est encombrant.
2. aspectJ : Un framework open source dédié à aop. Le framework aspectj est intégré dans le framework spring, et les fonctions aspectj peuvent être utilisées via spring.
Le framework aspectJ implémente aop de deux manières :
1. Utiliser des fichiers de configuration xml : Configurer les transactions globales
2. Utiliser des annotations, nous devons faire des fonctions aop dans le projet, généralement utiliser des annotations, aspectj a 5 annotations.
6. Apprenez à utiliser le framework aspectj.
1) Le temps d'exécution de l'aspect Ce temps d'exécution est appelé Avis (notification, amélioration) dans la spécification et est
représenté par des annotations dans le cadre aspectj. Vous pouvez également utiliser des balises dans le fichier de configuration xml
1) @Before
2) @AfterReturning
3) @Around
4) @AfterThrowing
5) @After
2) Indique l'endroit où l'aspect est exécuté, en utilisant l'expression pointcut.
com.service.impl
com.bjpowrnode.service.impl
cn.crm.bjpowernode.service
execution(* *..service.*.*(..))
================================================= == ==================
Chapitre 4 : Intégrer le framework mybatis avec spring et l'utiliser comme un framework.
La technologie utilisée est : ioc.
Pourquoi ioc : Mybatis et spring peuvent être intégrés ensemble, comme un framework, car ioc peut créer des objets.
Les objets du framework mybatis peuvent être transmis à Spring pour une création unifiée, et les développeurs peuvent obtenir des objets à partir de Spring.
Les développeurs n'ont pas à faire face à deux frameworks ou plus en même temps, juste à faire face à un ressort
Étapes d'utilisation de mybatis, objet
1. Définir l'interface dao, StudentDao
2. Définir le fichier mappeur StudentDao.xml
3. Définir le fichier de configuration principal mybatis mybatis.xml
4. Créer l'objet proxy dao, StudentDao dao = SqlSession.getMapper(StudentDao.class) ;
Lister les étudiants = dao.selectStudents();
Pour utiliser l'objet dao, vous devez utiliser la méthode getMapper(),
comment utiliser la méthode getMapper() et quelles conditions sont requises
1. Pour obtenir l'objet SqlSession, vous devez utiliser la méthode openSession() de SqlSessionFactory.
2. Créez un objet SqlSessionFactory. En lisant le fichier de configuration principal de mybatis, un objet SqlSessionFactory peut être créé
L'objet SqlSessionFactory est requis, la SqlSession peut être obtenue en utilisant la Factory, et le dao peut être obtenu avec la SqlSession, le but est d'obtenir l'objet dao La
création de Factory nécessite de lire le fichier de configuration principal
Nous allons utiliser une classe de pool de connexions indépendante pour remplacer celle que mybatis apporte par défaut, et remettre la classe de pool de connexions à spring pour la création.
Fichier de configuration principal :
1. Informations sur la base de données
<environment id="mydev">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<!--数据库的驱动类名-->
<property name="driver" value="com.mysql.jdbc.Driver"/>
<!--连接数据库的url字符串-->
<property name="url" value="jdbc:mysql://localhost:3306/springdb"/>
<!--访问数据库的用户名-->
<property name="username" value="root"/>
<!--密码-->
<property name="password" value="123456"/>
</dataSource>
- L'emplacement du fichier mappeur
<mappers>
<mapper resource="com/bjpowernode/dao/StudentDao.xml"/>
<!--<mapper resource="com/bjpowernode/dao/SchoolDao.xml" />-->
</mappers>
================================================= == ============
Dans la description ci-dessus, nous devons laisser Spring créer les objets suivants
1. Un objet d'une classe de pool de connexion indépendante, utilisant le pool de connexion druide d'Ali
2. Objet SqlSessionFactory
3. Créer un objet dao
Ce qu'il faut apprendre, c'est la syntaxe de création des trois objets ci-dessus, en utilisant la balise bean de xml.
Pool de connexion : une collection de plusieurs objets de connexion de connexion, List connlist : connList est le pool de connexion
Utilisez généralement Connection pour accéder à la base de données
Connection conn =DriverManger.getConnection(url,username,password);
Statemenet stmt = conn.createStatement(sql);
stmt.executeQuery();
conn.close();
Utilisez le pool de connexions
pour créer des connexions au démarrage du programme
Connection c1 = ...
Connection c2 = ...
Connection c3 = ...
List<Connection> connlist = new ArrayLits();
connList.add(c1);
connList.add(c2);
connList.add(c3);
Connection conn = connList.get(0);
Statemenet stmt = conn.createStatement(sql);
stmt.executeQuery();
Remettre la connexion utilisée dans le pool de connexion
connList.add(conn);
Connection conn1 = connList.get(1);
Statemenet stmt = conn1.createStatement(sql);
stmt.executeQuery();
把使用过的connection放回到连接池
connList.add(conn1);
================================================= == =================
Spring transaction processing
Réponse à la question
1. Qu'est-ce qu'une transaction
Quand on parle de mysql, une transaction est proposée. Une transaction fait référence à un ensemble d'instructions SQL. Il existe plusieurs instructions SQL dans l'ensemble, qui
peuvent être insérer, mettre à jour, sélectionner, supprimer. Nous espérons que ces instructions SQL multiples peuvent réussir ou
échouer. L'exécution de ces instructions SQL est cohérente. , exécuté dans son ensemble.
2. Quand dois-je penser à utiliser des transactions
Lorsque mon opération implique l'obtention de plusieurs tables, ou l'insertion, la mise à jour et la suppression de plusieurs instructions SQL. Il faut s'assurer que
ces déclarations réussissent toutes à remplir ma fonction, ou échouent toutes à assurer que l'opération répond aux exigences.
Écrivez un programme en code Java pour contrôler la transaction. Où la transaction doit-elle être placée à ce moment ?
Sur la méthode métier de la classe de service, car la méthode métier appellera plusieurs méthodes dao et exécutera plusieurs instructions sql
3. Utilisez généralement JDBC pour accéder à la base de données, ou comment gérer les transactions lorsque mybatis accède à la base de données
jdbc访问数据库，处理事务：
Connection conn ;
conn.commit();
conn.rollback();
mybatis访问数据库，处理事务：
SqlSession.commit();
SqlSession.rollback();
hibernate访问数据库，处理事务：
Session.commit();
Session.rollback();
4.3 Quelles sont les lacunes de la méthode de traitement des transactions dans la question ?
1) Différentes technologies d'accès aux bases de données ont des objets et des méthodes différents pour le traitement des transactions.
Il est nécessaire de comprendre les principes d'utilisation des transactions dans différentes technologies d'accès aux bases de données.
2) Maîtriser la transaction logique de traitement dans diverses bases de données. Quand valider une transaction, quand réviser une transaction
3) Plusieurs façons de gérer une transaction.
Résumé : Il s'agit d'une variété de technologies d'accès aux bases de données, avec différents mécanismes, objets et méthodes de traitement des transactions.
5. Comment résoudre le problème
Spring fournit un modèle unifié pour le traitement des transactions, qui peut utiliser des étapes unifiées pour terminer le traitement des transactions de diverses technologies d'accès aux bases de données.
En utilisant le mécanisme de traitement des transactions de spring, le traitement des transactions de mybatis accédant à la base de données peut être complété.
En utilisant le mécanisme de traitement des transactions de spring, le traitement des transactions de hibernate accédant à la base de données peut être complété.
6. Pour traiter la transaction, comment le faire, quel
modèle de ressort pour traiter la transaction et les étapes utilisées sont tous fixes. Fournissez simplement les informations utilisées par la transaction au printemps
1) La transaction interne valide, annule la transaction et utilise l'objet gestionnaire de transactions pour terminer la validation à votre place. Le
gestionnaire de transactions de restauration est une interface et ses nombreuses classes d'implémentation.
Interface : PlatformTransactionManager, qui définit l'importante méthode de validation des transactions,
classe d'implémentation de restauration : spring a créé la classe de traitement des transactions correspondant à chaque technologie d'accès à la base de données.
Mybatis accède à la base de données—spring crée DataSourceTransactionManager
hibernate accède à la base de données—spring crée HibernateTransactionManager
怎么使用：你需要告诉spring 你用是那种数据库的访问技术，怎么告诉spring呢？
声明数据库访问技术对于的事务管理器实现类， 在spring的配置文件中使用<bean>声明就可以了
例如，你要使用mybatis访问数据库，你应该在xml配置文件中
<bean id=“xxx" class="...DataSourceTransactionManager">
2) Quel type de transaction est requis par votre méthode commerciale, en indiquant le type de transaction requis.
Décrivez les transactions requises par la méthode :
1) Niveau d'isolation des transactions : Il existe 4 valeurs.
PAR DÉFAUT : utilise le niveau d'isolation de transaction par défaut de la base de données. La valeur par défaut de MySql est REPEATABLE_READ ; la valeur par défaut d'Oracle est READ_COMMITTED.
➢ READ_UNCOMMITTED : lecture non validée. Aucun problème de simultanéité n'a été résolu.
➢ READ_COMMITTED : lecture validée. Résolvez les lectures sales, les lectures non répétables et les lectures fantômes.
➢ REPEATABLE_READ : lecture répétable. Résoudre les lectures modifiées, les lectures non répétables et les lectures fantômes
➢ SERIALIZABLE : sérialiser. Il n'y a pas de problèmes de concurrence.
2) 事务的超时时间： 表示一个方法最长的执行时间，如果方法执行时超过了时间，事务就回滚。
单位是秒， 整数值， 默认是 -1.
3）事务的传播行为 ： 控制业务方法是不是有事务的， 是什么样的事务的。
7个传播行为，表示你的业务方法调用时，事务在方法之间是如果使用的。
PROPAGATION_REQUIRED
PROPAGATION_REQUIRES_NEW
PROPAGATION_SUPPORTS
以上三个需要掌握的
PROPAGATION_MANDATORY
PROPAGATION_NESTED
PROPAGATION_NEVER
PROPAGATION_NOT_SUPPORTED
3) Lorsque la transaction valide la transaction et annule la transaction
1) Lorsque votre méthode métier est exécutée avec succès et qu'aucune exception n'est levée, lorsque la méthode est exécutée, spring valide la transaction après l'exécution de la méthode. validation du gestionnaire de transactions
2）当你的业务方法抛出运行时异常或ERROR， spring执行回滚，调用事务管理器的rollback
运行时异常的定义： RuntimeException 和他的子类都是运行时异常， 例如NullPointException , NumberFormatException
3) 当你的业务方法抛出非运行时异常， 主要是受查异常时，提交事务
受查异常：在你写代码中，必须处理的异常。例如IOException, SQLException
Résumez les affaires du printemps
1. Ce qui gère la transaction est la gestion des transactions et sa classe d'implémentation
2. La transaction de spring est un modèle unifié
1) spécifiez la classe d'implémentation du gestionnaire de transactions à utiliser, utilisez
2) spécifiez quelles classes et méthodes doivent rejoindre la fonction de transaction
3 ) Spécifie le niveau d'isolement, le comportement de propagation et les délais d'attente requis par la méthode
你需要告诉spring，你的项目中类信息，方法的名称，方法的事务传播行为。
Solutions de traitement des transactions fournies dans le cadre de printemps
1. Convient aux projets de petite et moyenne taille, solutions d'annotation.
Le framework Spring utilise aop pour implémenter la fonction d'ajout de transactions aux méthodes métier et utilise l'annotation @Transactional pour ajouter des transactions.
L'annotation @Transactional est la propre annotation du framework Spring, placée au-dessus de la méthode publique, indiquant que la méthode actuelle a une transaction.
Vous pouvez attribuer des valeurs aux attributs de l'annotation, indiquant le niveau d'isolement spécifique, le comportement de propagation, les informations sur les exceptions, etc.
Étapes pour utiliser @Transactional :
1. Vous devez déclarer l'objet gestionnaire de transactions
2. Activez le pilote d'annotation de transaction et indiquez au framework Spring que je souhaite utiliser des annotations pour gérer les transactions.
Spring utilise le mécanisme aop pour créer l'objet proxy de classe où se trouve @Transactional et ajouter des fonctions de transaction à la méthode.
Spring ajoute des transactions aux méthodes commerciales :
avant l'exécution de votre méthode commerciale, démarrez d'abord la transaction, validez ou annulez la transaction après la méthode commerciale et utilisez la notification surround d'aop
@Around("你要增加的事务功能的业务方法名称")
Object myAround(){
开启事务，spring给你开启
try{
buy(1001,10);
spring的事务管理器.commit();
}catch(Exception e){
spring的事务管理器.rollback();
}
}
3. Ajoutez @Trancational au-dessus de votre méthode
2. Il convient aux projets à grande échelle. De nombreuses classes et méthodes nécessitent un grand nombre de transactions de configuration. Utilisez la fonction de cadre aspectj pour déclarer les transactions requises par les classes et les méthodes dans le fichier de configuration Spring . De cette façon, les méthodes commerciales et la configuration des transactions sont complètement séparées.
Étapes d'implémentation : toutes sont implémentées dans le fichier de configuration xml.
1) Pour utiliser le framework aspectj, vous devez ajouter la dépendance
org.springframework
spring-aspects
5.2.5.RELEASE
2）声明事务管理器对象
<bean id="xx" class="DataSourceTransactionManager">
3) 声明方法需要的事务类型（配置方法的事务属性【隔离级别，传播行为，超时】）
4) 配置aop：指定哪些哪类要创建代理。
================================================= == ===============================
Chapitre 6 : Comment utiliser les objets conteneurs dans les projets Web.
1. Ce qui est fait, c'est que le projet javase a une méthode principale et que le code d'exécution consiste à exécuter la méthode principale.L'objet
conteneur créé dans le
ApplicationContext principal ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
2. Le projet Web s'exécute sur le serveur Tomcat. Démarrez tomcat ensemble et le projet est en cours d'exécution.
Exigences :
l'objet conteneur dans le projet Web ne doit être créé qu'une seule fois et l'objet conteneur est placé dans la portée globale ServletContext.
Comment faire :
utilisez un écouteur pour créer un conteneur et le stocker dans le ServletContext lorsque l'objet de portée globale est créé
监听器作用：
1）创建容器对象，执行 ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
2）把容器对象放入到ServletContext， ServletContext.setAttribute(key,ctx)
监听器可以自己创建，也可以使用框架中提供好的ContextLoaderListener
private WebApplicationContext context;
public interface WebApplicationContext extends ApplicationContext
ApplicationContext:javase项目中使用的容器对象
WebApplicationContext：web项目中的使用的容器对象
把创建的容器对象，放入到全局作用域
key： WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE
WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE
value：this.context
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);