當前位置：首頁 > 前端技术 > javascript >内容正文

javascript

Spring的使用

發布時間：2024/3/24 javascript 48 豆豆

生活随笔收集整理的這篇文章主要介紹了 Spring的使用小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

Spring的簡單使用

1、傳統的三層架構問題

M：Model

? pojo service DAO

V：View

? HTML jsp

C：Controller

? Servlet

Controller------------------>Service-------------------->DAO

Servlet 提供事務 JDBC|dbutils

? 整合Controller的框架以及DAO的框架

SpringMVC

我們可以這樣認為：Controller-----依賴---->Service-----依賴----->DAO

2、Spring是什么

Spring是一個用來做對象創建、以及管理對象之間依賴關系的這樣一個框架

管理依賴關系：Controller-----依賴---->Service-----依賴----->DAO

對象創建：原來創建對象(new 反射對象克隆)----有了Spring之后(Spring幫我們自動創建)

Spring：春天程序員的春天來了

3、Spring能干什么

3.1、Spring在開發中到底能干嗎?

1、為業務邏輯層提供事務

2、整合第三方框架相當于是整個結構中的一個粘合劑

3、提供了控制器的解決方案

4、提供了控制器的解決方案 JdbcTemplate

5、提供了郵件的整合方案

6、提供了Aop編程的這種思想

7、提供了Web支持的解決方案

8、IOC、DI

3.2、Spring中的七大模塊以及功能

Spring Core ：IOC DI

Spring Aop ：面向切面編程的一些東西

Spring DAO：DAO層的解決方案 ----------->JdbcTemplate

Spring ORM：這個包簡單的說就是提供了第三方數據庫訪問的框架的整合 (iBatis、Hibernate)

? O：Obeject

? R：Relation

? M：Mapping

JAVA對象通過映射關系直接映射到數據庫表的這樣一門技術其實就是DAO層的解決方案

Spring Web：提供了Web項目的一些支持

Spring WebMVC：Spring MVC------控制器的解決方案

Spring Context：主要提供的是上下文的支持

3.3、Spring的家族都有哪些框架

Spring SpringBoot SpringSecurity SpringCloud(不是一個框架是一系列做微服務框架的集合)

###4、Spring中的IOC的問題

IOC：控制反轉

誰控制了誰?

? 以前我們創建Java對象的時候自己創建的 new這種方式去完成

? JAVA對象的創建就不再由我們去創建而是由Spring自動去創建

? Spring控制了Java對象的創建

什么東西反轉了?

? 創建對象的權利給反轉了

5、Spring中DI問題

6、Spring的第一個HelloWorld程序

6.1、導包

<dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>4.3.7.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>4.3.7.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-web</artifactId><version>4.3.7.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>4.3.7.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>4.3.7.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>4.3.7.RELEASE</version></dependency>

6.2、在main下創建resources文件夾設置成資源文件

6.3、在resource下創建一個bean-base.xml文件

6.4、準備一個java類

@Data @AllArgsConstructor @NoArgsConstructor public class User {private int id;private String userName;private String password; }

6.5、在xml中進行對象的申明

<bean id="user" class="com.qf.cd.helloword.User"></bean>

6.6、測試文件

//第一步：我們需要獲取這個對象的容器(IOC容器)ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-base.xml");//第二步：獲取這個Java對象User user = context.getBean(User.class);//第三步：打印這個對象System.out.println(user);

7、Spring的實現方式之XML

7.1、基本的配置

<bean id="user111"name="userbobo"scope="singleton"init-method="init"destroy-method="destory"class="com.qf.cd.helloword.User"></bean>

7.2、有參數對象的對象的構建

7.3、工廠創建對象的方式

<bean id="user4" class="com.qf.cd.helloword.UserFactory" factory-method="getStaticInstance"></bean>

7.4、出現的問題

通過類型找對象的時候、如果當前類的實例在IOC容器中存在多個的話那么是會報錯因為他不知道你找到是哪一個Java對象

<bean id="userService" class="com.qf.cd.helloword.UserService" depends-on="userDAO,user"></bean><bean id="user" class="com.qf.cd.helloword.User"></bean><bean id="userDAO" class="com.qf.cd.helloword.UserDAO"></bean>

8、Spring中的DI(依賴注入)

依賴：誰依賴于誰?

? 在開發中：Controller-----依賴于-----Service-------依賴于DAO

? 注入了什么東西?

? 1、JAVA對象

? 2、可以是注入的咋們的值

8.1、通過構造器進行注入(就是給這個對象賦值)

8.1.1、首先在bean.xml中進行申明

<bean id="userDAO" class="com.qf.cd.di.UserDAO"></bean><bean id="userService" class="com.qf.cd.di.UserService"><constructor-arg name="userDAO" ref="userDAO"></constructor-arg></bean>

8.1.2、然后給一個構造器

public class UserService {private UserDAO userDAO;public UserService(UserDAO userDAO){this.userDAO=userDAO;}/*** 登陸*/public void login(){userDAO.aa();}}

8.2、通過Set方法進行注入

8.2.1、編寫類成員屬性的Set方法

private UserDAO userDAO1111;public void setUserDAO1111(UserDAO userDAO1111) {this.userDAO1111 = userDAO1111;}

8.2.2、編寫配置文件

<bean id="userDAO" class="com.qf.cd.di.UserDAO"></bean><bean id="userService" class="com.qf.cd.di.UserService"><property name="userDAO1111" ref="userDAO"></property></bean>

8.3、p標簽注入

8.3.1、首先編寫Set方法(p標簽的實質還是Set注入)

private UserDAO userDAO;// p：標簽注入的時候底層實際上還是 Set注入的方式// 所以必須要有Set方法public void setUserDAO(UserDAO userDAO) {this.userDAO = userDAO;}

8.3.2、編寫配置文件

<bean id="userDAO" class="com.qf.cd.di.UserDAO"></bean><bean id="userService" class="com.qf.cd.di.UserService" p:userDAO-ref="userDAO"></bean>

8.4、內部bean注入

8.4.1、編寫set方法

private UserDAO userDAO;// p：標簽注入的時候底層實際上還是 Set注入的方式// 所以必須要有Set方法public void setUserDAO(UserDAO userDAO) {this.userDAO = userDAO;}

8.4.2、編寫配置文件

<bean id="userService" class="com.qf.cd.di.UserService"><property name="userDAO"><bean class="com.qf.cd.di.UserDAO"></bean></property></bean>

總結一下：對象的注入方式：Set注入、另外一種是構造器注入

9、自動裝配模型

10、注解模式實現IOC、DI功能

@Component：這個注解表示的意思是將類生成對象放到IOC容器中 @Autowired ：先通過類型找對象找不到再通過名字來找對象注意 @Resource(type = UserDAO.class) ：這個注解是先通過名字再通過注解來找對象注意 @PostConstruct：對象放到IOC容器之前進行初始化的操作 @PreDestroy：對象要銷毀之前要進行對象的回收操作 @Repository：這個表示的是對象放到IOC容器中去 //這個注解一般用在DAO層 @Service：這個注解也是將對象放到IOC容器中

注意

@Override protected void finalize() throws Throwable {super.finalize(); } 每個對象的這個方法都可以干預對象在JVM回收數據的時候不被回收

11、代理的設計模式

代理的設計模式解決了什么問題?

代理的設計模式解決的問題：能夠動態的監控一個類中所有方法的執行以及在這個方法的執行的前后動態植入咋們的代碼

代理：簡單的說就是對原來的功能的增強

比如：為業務邏輯層提供事務

? @Configuration

? Spring整合iBatis

11.1、靜態代理

靜態代理的前提是當前的類必須實現接口否則沒法玩

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-615h7stg-1592395564225)(pic\1592288049671.png)]

11.1.1、被代理類的接口

public interface IUserService {void zz(); }

11.1.2、被代理類

public class UserService implements IUserService{/*** 轉賬這個方法*/public void zz(){System.out.println("鎖定張三的賬戶");System.out.println("張三的賬戶預減1000元");System.out.println("檢測李四的賬戶是否可用");System.out.println("李四的賬戶增加1000元");} }

11.1.3、代理類

public class UserServiceProxy implements IUserService{private IUserService userService;public UserServiceProxy(IUserService userService ){this.userService=userService;}@Overridepublic void zz() {System.out.println("添加事務");userService.zz();System.out.println("提交事務");} }

11.2、動態代理(JDK代理)

動態：被代理的類的對象是自動生成的

? 被代理的類是自動生成的

? 被代理的類的對象也是自動生成的

? JDK代理：原因是使用的是JDK本身的API

前提：被代理的類必須要實現接口

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-mkxIXJu0-1592395564227)(pic\1592290057779.png)]

11.2.1、被代理類實現的接口

public interface IUserService {void zz(); }

11.2.2、被代理的類

public class UserService implements IUserService {/*** 轉賬這個方法*/public void zz(){System.out.println("鎖定張三的賬戶");System.out.println("張三的賬戶預減1000元");System.out.println("檢測李四的賬戶是否可用");System.out.println("李四的賬戶增加1000元");} }

11.2.3、代理類實現

public static void main(String[] args){/*** 第一個參數:classloader：表示的是類加載器寫法是死的類.class.getClassLoader* 第二個參數：interfaces：當前類實現的接口之所以要這個東西是因為生成代理類的時候需要實現接口* 1：被代理的是個類：類.class.getInterface* 2：被代理的是是個接口： new Class[]{接口.class}* 第三個參數：invationHandle* 方法的監聽的回調接口----當你執行這個接口中的某一個方法的時候就會自動的回調到這個方法中來*/IUserService userService= (IUserService) Proxy.newProxyInstance(UserService.class.getClassLoader(),UserService.class.getInterfaces(),new InvocationHandler() { //執行到每一個方法都會執行到這里來/**** @param proxy ：代理對象* @param method ：當前執行的方法* @param args ：當前執行方法的參數封裝* @return* @throws Throwable*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//在方法執行的前后進行拓展System.out.println("打開事務");Object invoke = method.invoke(new UserService(), args);System.out.println("關閉事務");return invoke;}});

11.3、CGLIB代理

思考一個問題：

靜態代理和動態代理都有一個前提：被代理的類必須實現接口

假設一個類沒有實現接口需要增強怎么辦呢?

CGLIB代理在這種場景下就應運而生了…

CGLIB代理本身是可以代理任意的一個類這個類可以不實現接口也可以實現接口

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-qQ4u2oCu-1592395564229)(pic\1592291117537.png)]

11.3.1、被代理的類

public class UserService{/*** 轉賬這個方法*/public void zz(){System.out.println("鎖定張三的賬戶");System.out.println("張三的賬戶預減1000元");System.out.println("檢測李四的賬戶是否可用");System.out.println("李四的賬戶增加1000元");} }

11.3.2、代理的類

public class UserServiceProxy{/*** 獲取這個代理類* @return*/public static UserService getUserServiceProxy(){Enhancer enhancer=new Enhancer();//設置生成的類的爹是誰enhancer.setSuperclass(UserService.class);//設置方法監聽的回調enhancer.setCallback(new MyMethodInterceptor());return (UserService) enhancer.create();}/*** 方法的監聽*/static class MyMethodInterceptor implements MethodInterceptor{/**** @param obj：代理對象* @param method ：當前執行的方法* @param args ：當前執行方法的參數* @param proxy ：這個是方法代理* @return* @throws Throwable*/@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {//在這里進行增強System.out.println("開啟事務");Object invoke = method.invoke(new UserService(), args);System.out.println("提交事務");return invoke;}} }

#####11.3.3、測試實現

public class Test001 {public static void main(String[] args){UserService userServiceProxy = UserServiceProxy.getUserServiceProxy();userServiceProxy.zz();} }

12、AOP面向切面的編程

什么叫面向切面編程?

就是在編程的時候將我們的重復的代碼抽取出來形成方法再形成一個類、這個類就是切面類、當我們在執行原來代碼的時候使用代理的設計模式動態植入我們抽取出來的代碼的這種編程方式就稱為面向切面編程

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-yY20B6hf-1592395564231)(pic\1592293344476.png)]

12.1、手動實現下面向切面編程(使用CGLIB代理來實現)

12.1.1、編寫業務類

@Component public class UserService {/*** 這是一個add的方法*/public void add(){System.out.println("添加數據完成....");}}

12.1.2、編寫aop類

@Component public class Aop {public void begin(){System.out.println("開啟事務");}public void commit(){System.out.println("提交事務");}}

12.1.3、編寫代理類

@Component public class UserServiceProxy implements MethodInterceptor {@AutowiredAop aop;/*** 獲取代理類* @return*/public UserService getUserServiceProxy(){Enhancer enhancer=new Enhancer();enhancer.setSuperclass(UserService.class);enhancer.setCallback(this);return (UserService) enhancer.create();}/*** 這里就是方法的攔截* @param obj* @param method* @param args* @param proxy* @return* @throws Throwable*/@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {aop.begin();Object invoke = method.invoke(new UserService(), args);aop.commit();return invoke;} }

12.1.4、編寫配置文件

12.1.5、編寫測試類

public class Test001 {public static void main(String[] args){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-aop1.xml");UserService userServiceProxy = context.getBean(UserServiceProxy.class).getUserServiceProxy();userServiceProxy.add();} }

12.2、使用XML配置模式實現AOP編程

12.2.1、編寫業務類

public class UserService {public void zz(){System.out.println("轉賬功能實現.....");//int k=1/0;}public void pp(){System.out.println("這里實現了ppp的功能.....");}public void kb(){System.out.println("這里實現了口碑這個功能.....");} }

12.2.2、編寫AOP的類

public class Aop {public void begin(){System.out.println("打開事務....");}public void commit(){System.out.println("提交事務.....");}/*** 方法調用完成執行返回的時候就會自動執行這個方法*/public void returning(){System.out.println("這里是returning方法.....");}/*** 調用切入點表達式的時候如果方法拋出了異常那么就執行這個方法*/public void afterThroeing(){System.out.println("拋出異常了....");}/*** 環繞*/public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {//這里有點類似那個過濾器中的放行System.out.println("這里是環繞前");proceedingJoinPoint.proceed();System.out.println("這里是環繞后");}}

12.2.3、編寫配置

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"xmlns:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:tx="http://www.springframework.org/schema/tx"xmlns:mvc="http://www.springframework.org/schema/mvc"xmlns:task="http://www.springframework.org/schema/task"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.0.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.0.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-4.0.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-4.0.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc.xsdhttp://www.springframework.org/schema/taskhttp://www.springframework.org/schema/task/spring-task-3.1.xsd"><bean id="userService" class="com.qf.cd.aop.xml.UserService"></bean><bean id="aop" class="com.qf.cd.aop.xml.Aop"></bean><aop:config><aop:pointcut id="pt" expression="execution(* com.qf.cd.aop.xml.*.*(..))"></aop:pointcut><aop:aspect ref="aop"><aop:before method="begin" pointcut-ref="pt"></aop:before><aop:after method="commit" pointcut-ref="pt"></aop:after><aop:after-returning method="returning" pointcut-ref="pt"></aop:after-returning><aop:after-throwing method="afterThroeing" pointcut-ref="pt"></aop:after-throwing><aop:around method="around" pointcut-ref="pt"></aop:around></aop:aspect></aop:config> </beans>

12.2.4、編寫測試文件

public static void main(String[] args){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-aop2.xml");UserService userService = context.getBean(UserService.class);userService.zz();}

12.3、使用注解模式完成AOP編程

12.3.1、注解的含義

@Aspect ：表示的是當前這個類是一個切面類 @Before：前置處理器 @After：后置處理器 @AfterReturning：這個表示的是在返回值的時候進行調用 @AfterThrowing：這個表示的是在拋出異常的時候調用 @Around：環繞通知 @Pointcut：這個表示的是一個切入點表達式

12.3.2、編寫配置文件

<aop:aspectj-autoproxy></aop:aspectj-autoproxy><context:component-scan base-package="com.qf.cd.aop.annotation"></context:component-scan>

12.3.3、編寫業務類

@Service public class UserService {public void zz(){System.out.println("轉賬功能實現.....");//int k=1/0;}public void pp(){System.out.println("這里實現了ppp的功能.....");}public void kb(){System.out.println("這里實現了口碑這個功能.....");} }

12.3.4、編寫Aop的類

@Component //放到IOC容器 @Aspect //表明是一個切面類 public class Aop {/*** 定義一個切入點表達式*/@Pointcut(value = "execution(* com.qf.cd.aop.annotation.UserService.*(..))")public void pt(){}@Before(value = "pt()")public void begin(){System.out.println("打開事務....");}@After(value = "pt()")public void commit(){System.out.println("提交事務.....");}/*** 方法調用完成執行返回的時候就會自動執行這個方法*/@AfterReturning(value = "pt()")public void returning(){System.out.println("這里是returning方法.....");}/*** 調用切入點表達式的時候如果方法拋出了異常那么就執行這個方法*/@AfterThrowing(value = "pt()")public void afterThroeing(){System.out.println("拋出異常了....");}/*** 環繞*/@Around(value = "pt()")public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {//這里有點類似那個過濾器中的放行System.out.println("這里是環繞前");proceedingJoinPoint.proceed();System.out.println("這里是環繞后");} }

12.3.5、測試

public static void main(String[] args){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-aop3.xml");UserService userService = context.getBean(UserService.class);userService.kb();}

13、Spring的DAO模塊

DAO模塊：類似于dbutils 這個工具類、主要用來訪問數據庫的

13.1、導入連接池的包

<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.22</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.0.7</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>4.3.7.RELEASE</version></dependency>

13.2、配置JdbcTemplate

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="url" value="jdbc:mysql:///cd200101"></property><property name="driverClassName" value="com.mysql.jdbc.Driver"></property><property name="username" value="root"></property><property name="password" value="root"></property></bean><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"></property></bean><context:component-scan base-package="com.qf.cd.dao"></context:component-scan>

13.3、編寫DAO

@Component public class UserDAO {@Autowiredprivate JdbcTemplate jdbcTemplate;public void update(){jdbcTemplate.update("insert into t_user(userName,password) values(?,?)","小波波","123");} }

13.4、測試

public static void main(String[] args){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-dao.xml");UserDAO userDAO = context.getBean(UserDAO.class);userDAO.update();}

14、Spring中的事務問題

說明個問題

事務無非就是具有原子性、一些列的操作同時成功或者同時失敗

假設你來設計個事務：怎么保證這一些列的操作同時成功或者同時失敗呢?

開啟事務的時候 ----- 開始做記錄

? 把每一個操作都做一個記錄

當前的業務如果做完了----如果沒有產生異常------直接結束就可以了

? 如果產生了異常---------把所有的記錄做一個還原

事務有哪些分類：

事務如果按照粗細程度來劃分：

? 粗粒度事務：給整個方法添加事務

? 細粒度事務：給這個方法中某幾行代碼添加事務

事務如果按照范圍來劃分：

? 全局事務：跨數據庫的這樣一個事務

? 局部事務：所有的事務是在一個庫里面

14.1、Spring中通過xml來配置事務

14.1.1、編寫數據訪問的類

@Component public class UserDAO implements IUserDAO{@Autowiredprivate JdbcTemplate jdbcTemplate;/*** 更新數據庫的操作*/public void update(){jdbcTemplate.update("update t_user set userName=?,password=?","鐵蛋","119");} }

14.1.2、編寫業務邏輯類

@Service public class UserService {@Autowiredprivate IUserDAO userDAO;public void update(){userDAO.update();int k=1/0;} }

14.1.3、編寫配置文件

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"xmlns:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:tx="http://www.springframework.org/schema/tx"xmlns:mvc="http://www.springframework.org/schema/mvc"xmlns:task="http://www.springframework.org/schema/task"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.0.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.0.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-4.0.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-4.0.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc.xsdhttp://www.springframework.org/schema/taskhttp://www.springframework.org/schema/task/spring-task-3.1.xsd"><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="url" value="jdbc:mysql:///cd200101"></property><property name="driverClassName" value="com.mysql.jdbc.Driver"></property><property name="username" value="root"></property><property name="password" value="root"></property></bean><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"></property></bean><bean id="tx-manager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"></property></bean><tx:advice id="tx-advice" transaction-manager="tx-manager"><tx:attributes><tx:method name="*" read-only="false" /></tx:attributes></tx:advice><aop:config><aop:pointcut id="pt" expression="execution(* com.qf.cd.tx.UserService.*(..))"></aop:pointcut><aop:advisor advice-ref="tx-advice" pointcut-ref="pt"></aop:advisor></aop:config><aop:aspectj-autoproxy></aop:aspectj-autoproxy><context:component-scan base-package="com.qf.cd.tx"></context:component-scan> </beans>

14.1.4、編寫測試類

public static void main(String[] args){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean-tx1.xml");UserService userService = context.getBean(UserService.class);userService.update();}

14.2、Spring中通過注解的模式來實現事務配置

14.2.1、編寫DAO類

同上

#####14.2.2、編寫Service類

@Service public class UserService {@Autowiredprivate IUserDAO userDAO;@Transactional //這個注解使用在類上面那么就對所有的方法添加了事務public void update(){userDAO.update();int k=1/0;}

14.2.3、編寫配置文件

14.2.4、使用那注解

@Transactional

15、事務中屬性的測試

略

16、Spring中Java編寫配置文件的問題

16.1、發展史

Spring在1.x時代--------最先推出的是xml編寫配置文件

Spring在2.x時代-------推出了使用注解模式代替XML配置

Spring在3.x的時代-----推出了使用Java來編寫配置文件

16.2、設計到的注解

16.3、測試的配置案例

@Configuration //這個注解就表示的是當前的java文件是一個配置文件 //@ComponentScan(basePackages = {"com.qf.cd.javaconfig"}) //配置的是包的掃描 @PropertySource(value = "classpath:db.properties",ignoreResourceNotFound = false) //ignoreResourceNotFound這個表示的是沒找到這個文件是否要忽略 @ImportResource(value = {"classpath:bean-javaconfig.xml"}) //這個表示的是讀取外部的xml配置文件 public class AppConfig {@Value("${jdbcUrl}") //這個就表示的是將 properties中的鍵值對的值映射到下面的成員變量中private String jdbcUrl;@Value("${driverClass}")private String driverClass;@Value("${user}")private String user;@Value("${password}")private String password;/*** 注意：* @return*/ // @Bean //就表示的是要把下面方法返回的對象放到IOC容器中 // public UserDAO userDAO(){ // return new UserDAO(); // }// @Bean // public UserService userService(){ // return new UserService(); // }// @Bean // public DruidDataSource dataSource(){ // DruidDataSource druidDataSource = new DruidDataSource(); // //1001個步驟 // druidDataSource.setUrl(jdbcUrl); // druidDataSource.setDriverClassName(driverClass); // druidDataSource.setUsername(user); // druidDataSource.setPassword(password); // return druidDataSource; // } }

總結

以上是生活随笔為你收集整理的Spring的使用的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

Spring

上一篇： antd组件库封装44-添加字体变量方案
下一篇： Spring4 MVC Hello Wr

日韩av黄I国产麻豆传媒I国产91av视频在线观看I日韩一区二区三区在线看I美女国产在线I麻豆视频国产在线观看I成人黄色短片

javascript

Spring的使用

Spring的簡單使用

1、傳統的三層架構問題

2、Spring是什么

3、Spring能干什么

3.1、Spring在開發中到底能干嗎?

3.2、Spring中的七大模塊以及功能

3.3、Spring的家族都有哪些框架

5、Spring中DI問題

6、Spring的第一個HelloWorld程序

6.1、導包

6.2、在main下創建resources文件夾設置成資源文件

6.3、在resource下創建一個bean-base.xml文件

6.4、準備一個java類

6.5、在xml中進行對象的申明

6.6、測試文件

7、Spring的實現方式之XML

7.1、基本的配置

7.2、有參數對象的對象的構建

7.3、工廠創建對象的方式

7.4、出現的問題

8、Spring中的DI(依賴注入)

8.1、通過構造器進行注入(就是給這個對象賦值)

8.1.1、首先在bean.xml中進行申明

8.1.2、然后給一個構造器

8.2、通過Set方法進行注入

8.2.1、編寫類成員屬性的Set方法

8.2.2、編寫配置文件

8.3、p標簽注入

8.3.1、首先編寫Set方法(p標簽的實質還是Set注入)

8.3.2、編寫配置文件

8.4、內部bean注入

8.4.1、編寫set方法

8.4.2、編寫配置文件

9、自動裝配模型

10、注解模式實現IOC、DI功能

11、代理的設計模式

11.1、靜態代理

11.1.1、被代理類的接口

11.1.2、被代理類