框架技术与应用开发期末速成

spring

Spring简介

??? Spring是个java企业级应用的开源开发框架。Spring主要用来开发web应用是一个轻量级的控制反转(IOC)和面向切面(AOP)的容器框架。

Spring体系结构

核心容器:

Core模块
提供了框架的基本组成部分，包括TOC和依赖注入功能

Beans模块
提供 BeanFactory，它是一个工厂模式的复杂实现

Context模块
它是访问定义和配置的任何对象的媒介。ApplicationContext接口是其重点

SpEL模块
表达式语言

?Web层

web模块
提供了基本的面向web的集成功能，例如多个文件上传的功能和使用servlet监听器和初始化IOC容器

web-MVC模块
包含Spring的模型-视图-控制器(MVC)，实现了web应用程序

websocket模块
为webSocket-based提供了支持，而且在web应用程序中提供了客户端和服务器端之间通信的两种方式

Portlet模块
提供了在portlet环境中实现MVC

?数据访问/集成

JDBC模块
提供了删除冗余的JDBC相关编码的JDBC抽象层

ORM模块
为流行的对象关系映射API，包括JPA，JDO,Hibernate和iBatis,提供了集成层
OXM模块

提供了抽象层，它支持对JAXB,Castor,XMLBeans，JiBx和Xstream 的对象/XML映射实现Transactions模块
为实现特殊接口的类及所有的POJO支持编程式和声明式事务管理

JMS模块
Java消息服务，包含生产和消费的信息的功能

其他模块

AOP模块
提供了面向切面的编程实现，允许你定义方法拦截器和切入点Aspects模块
提供了与AspectJ的集成，这是一个功能强大且成熟的面向切面Messaging模块
处理来自websocket客户端的信息

Spring特征

三大特征:AOP、IOC、DI。

IOC : 控制反转
DI :依赖注入。
AOP : 面向切面编程

?Spring loC/DI概述

loc(控制反转)
使用目的:降低耦合度

正向控制:若要使用某个对象，需要自己去负责对象的创建。

反向控制:若要使用某个对象，只需要从 spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了spring框架。

DI的方式(依赖注入)

对象只提供普通的方法，容 权负责组件的装配，它会把符合依赖关系的对象通过属性(Javabean中的setter)或者是构造 传递给需要的对象。

?Spring loc容器

I0C容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IOC容器中统称为Bean。

常见的IoC容器实现方式包括 BeanFactory和ApplicationContext。
(1) BeanFactory: Spring内部使用的接口，不提倡开发人员使用。特点: 加载配置文件时不会创建对象，获取对象时才会创建对象。
(2) ApplicationContext: BeanFactory的子接口，提供了更多更强大的功能，一般由开发人员使用。特点: 加载配置文件时会把配置文件里的对象进行创建。

Spring框架入门案例

引入依赖到pom.xml中

<dependenctes>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.9</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>6.0.9</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>6.0.9</version>
    </dependency>
    <dependency>
        <groupId>commons-1ogging</groupId>
        <artifactId>commons-Togging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.8</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>6.0.9</version>
    </dependency>
</dependencies>

第一步：创建Maven 项目

第二步：创建Java和resource文件夹

第三步：点击install安装Maven

第一种：set方法注入

创建Book类

public class Book {

    private String bookName：

    private double price;

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    
    public void setPrice(double price) {
    this.price = price;
    }
   
    public void show(string bookName,double price){
        System.out.println("书名:"+bookName+" 价格:"+price);
    }
}

编写applicationContext.xml

<bean id="book" class="com.wuji.Book">
     <property name="bookName" value="aaa"></property>
     <property name="price" value="19999.11"></property>
</bean>
</beans>

编写测试类

public class client1 {
    public static void main(String[] args) {    
    //com.wuji.Book book=new com.wuji.Book();
    //book.setBookName("aaa");
    //book.setPrice(11.11);
    //book.show();

    ApplicationContext context=new ClassPathXmlApplicationContext;
    Book book = context.getBean( "book",Book.class );   
    book.show();
    }
}

通过控制反转交给spring容器去处理

第二种 有参构造方法注入

public class Book {
    private String bookName;
    private double price

    public Book(string bookName,double price) {
        this .bookName = bookName;    
        this.price = price;
    }
    public void show(){
        System.out.printIn(bookName+":"+price) ;
    }                                                            
}

<bean id="book”class="com.wuji.Book">
    <constructor-arg name="bookName”value="aaa"></constructor-arg>
    <constructor-arg name="price" value="199.9"></constructor-arg>
</bean>                                                                                        

?第三种：注解注入

首先添加依赖

<bean id="cat” class="com.Cat"></bean>
<bean id="dog" class="com.Dog"></bean>
<bean id="animal" class="com.Animal"></bean><context:annotation-config></context:annotation-config>
</beans>

创建一个cat dog 以及 animal类

public class Animal {

    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    public Cat getCat() {
        return cat;
    }
    public Dog getDog() {
    return dog;
    }
}

@Autowried：在属性上面加,自动按照类型注入，不关心bean的id，只要有唯一的类型匹配就可以注入成功。无需s?et方法。如果注入的bean在容器中类型不唯一时，它会把变量名作为bean的id，然后在容器中查找，找到则注入成功。如果没有找到一致的bean id则报错。

如果类型有多个，可以用@Qualifier

如

<bean id="cat1” class="com.Cat"></bean>
<bean id="cat2”class="com.Cat"></bean>
<bean id="dog1" class="com.Dog"></bean>
<bean id="dog2" class="com.Dog"></bean>
<bean id="animal" class="com.Animal"></bean><context:annotation-config></context:annotation-config>
</beans>

public class Animal {

    @Autowired
    @Qualifire(value = "cat1")
    private Cat cat;
    @Autowired
    @Qualifire(value = "dog1")
    private Dog dog;
    public Cat getCat() {
        return cat;
    }
    public Dog getDog() {
    return dog;
    }
}

@Qualifier:在自动搜索类型的基础上，再按照bean的id注入，属性value：用于指定bean的id。在给类成员注入数据时，不能独立使用，但在给方法的行参注入数据时，可以独立使用

既能按名称又能按类型来的注解？

@Resouce(name="")

@Componet 描述spring中的一个bean (使用后可以将xml中的bean去掉)

@Repository 将数据访问层 (Dao层) 的类标识为Spring中的bean

@service 将业务层 (Service层) 的类标识为Spring中的bean

@Contro11er 将控制层的类标识为Spring中的bean

spring的Bean

Bean的作用域

singleton: 单例模式: IOC容器中只会存在一个bean实例，无论多少bean引用它，始终指向相同的对象

prototype: 原型模式: IOC容器可以同时存在多个实例，当程序去获取bean时可创建出一个新的实例

request: 在一次Http请求中，容器会返回该Bean的同一实例。而对不同的Http请求则会产生新的Bean，而且该bean仅在当前Http Request内有效。
session: 在一次Http Session中，容器会返回该Bean的同一实例。而对不同的Session请求则会创建新的实例，该bean
实例仅在当前Session内有效。

global Session: 在一个全局的Http Session中，容器会返回该Bean的同一个实例，仅在使用portlet context时有效。

spring的AOP

AOP的简介

(Aspect oriented Programming)中文翻译过来是 面向切面编程底层实现也是基于 动态代理 完成的。

AOP术语

连接点 (JointPoint ):有可能调用AOP的地方叫做 连接点提供一组规则 来匹配Join Point
切点 ( PointCut):
通知 (Advice ):
切面(ASPECT):
切面的工作被称之为通知。
由切点 (Pointcut)和通知 (Advice) 组成

? AOP的实现方式

1.添加 SpringAOP 框架支持
2.定义切面和切点
3.定义通知

使用AOP织入，需要导入一个依赖包????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

UserSerivce接口

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

?UserServicelmpl实现类

public class UserServiceImpl implements UserService {
    @Override
    public void add() {System.out.println(“增加了一个用户");
    @Override
    public void delete() {System.out.println("删除了一个用户");
    @Override
    public void update() {System.out.println("更新了一个用户");
    @Override
    public void select() {System.out.println("查询了一个用户");
}

?例如，现在要在查询方法之前做一个预处理，在完成之后也做一个预处理

定义切面和切点

public class MyPointCut {
    public void before(){
        System.out.println("=========方法执行前 预处理=========");
    }
    public void after(){
        System.out.println("=========方法执行后 执行完毕=========);
    }
}

<bean id="userService" class="com.service.impl.UserServiceImpl"></bean>
<bean id="mypt"class="com.pointCut.MyPointCut"></bean>
<aop:config>
定义切面
    <aop;aspect ref="mypt">

切点
    <aop:pointcut id="point"                 expression="execution(voidcom.service,impl.UserServiceImpl.select())"/>
通知
    <aop;before method="before" pointcut-ref="point"></aop:before>
    <aop:after method-"after" pointcut-ref="point"></aop;after>
    </aop:aspect></aop:config>
</beans>

???? AOP实现注解

? 在UserServicelmpl实现类 开头加上 @Service

给MyPoint添加注解

@Aspect
@Component
public class MyPointCut {
    @Before("execution(void com.service.impl).select()")
    public void before(){
        System.out.println("=========方法执行前 预处理=========");
    }
    @After("execution(void com.service.impl).select()")
    public void after(){
        System.out.println("=========方法执行后 执行完毕=========);
    }
}

?? 测试

public class client1 {
    public static void main(string[] args) {

ApplicationContext context=new ClassPathXmlApplicationContext(configlocation:"applicationContext.xml");
UserService userService = context.getBean( s: "userService", UserService.class);
System.out.printIn(userService.getClass());
userService.select();
}
}

通知类型 ??????????????????????????????????????????????????????????????????????????????????????????????????????????????????????
1 前置通知使用 @Before: 通知方法会在目标方法调用之前执行
2 后置通知使用 @After: 通知方法会在目标方法返回或者抛出异常后调用
3 返回之后通知使用 @AfterReturning: 通知方法会在目标方法返回后调用
4 抛异常后通知使用 @AfterThrowing: 通知方法会在目标方法抛出异常后调用5 环绕通知使用 @Around: 通知包裹了被通知的方法，在被通知的方法通知之前和调用之后执行自定义的行???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????

spring整合mybits

1.引入依赖

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.</version>
</dependency>

??? 2.MybatisConfig;java

public class MybatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSourcedataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
    msc.setBasePackage("com.itheima.dao");
    return msc;
    }
}

?????? 3.测试类

public class client{
    public static void main(String[] args) {
        ApplicationContext ctx = newAnnotationConfigApplicationContext(SpringConfig.class);
        AccountService accountService = ctx.getBean(AccountService.class);
        Account ac = accountService.findById(2);
        System.out.printIn(ac);
    }
}

springMVC????????????????????????????????????????????????????????????????????????????????????????????

SpringMVC概述
SpringMVC技术与Servlet技术功能等同，均属于web层开发技术

?SpringMVC是一种基于Java实现MVC模型的轻量级Web框架优点
使用简单，开发便捷 (相比于Servlet)
灵活性强

SpringMVC入门案例

1.使用SpringMVC技术需要先导入SpringMVC坐标与Servlet坐标

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax,servlet-api</artifactId>
<version>3.1.</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>

2.创建SpringMVC控制器类 (等同于Servlet功能）

@Controller
public class UserController {
    @RequestMapping("/save" )
    @ResponseBody
    public String save(){
    System.out.println("user save ...");
    return "{'info':'springmvc'}";
    }
}

3.初始化SpringMVC环境 (同Spring环境) ，设定SpringMVC加载对应的bean

@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}

?4.初始化Servlet容器，加载SpringMVC环境，并设置SpringMVC技术处理的请求

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {        protected WebApplicationContext createServletApplicationContext(){
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigwebApplicationContext();
ctx.register(SpringMvcConfig.class);
return ctx;
}
protected String[] getServletMappings() {
    return new String[]{"/" };
}
protected WebApplicationContext createRootApplicationContext() {
return null;
}
}

?UserController.java

//2.定义controller
//2.1使用@ControLler定义bean
@Controller
public class UserController {
//2.2设置当前操作的访问路径
    @RequestMapping(~"/save")
//2.3设置当前操作的返回值类型
    @ResponseBody
    public String save(){
    System.out.println("user save...");
    return "{'module':'springmvc'}";
    }
}

配置类

//3.创建springmvc的配置文件，加裁controLLer对应的bean
@Configuration 
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}