华清远见-Java框架个人总结

最新推荐文章于 2022-11-23 11:43:15 发布

qq_55069674

最新推荐文章于 2022-11-23 11:43:15 发布

阅读量184

点赞数

文章标签： java mybatis spring spring boot

本文链接：https://blog.csdn.net/qq_55069674/article/details/127372546

版权

在Java框架的学习中，我们主要学习了spring、springMVC、Mybatis、springBoot，以及Mybatis-plus。这些框架在我看来都是由繁到简，越到后面，框架的使用就会越简单。下面我将总结一下这些框架的使用步骤。

1.spring框架的使用：

spring框架的概念：spring是一个开源容器框架，可以接管web层，业务层，dao层，持久层的组件，并且可以配置各种bean,和维护bean与bean之间的关系。其核心就是控制反转(IOC),和面向切面(AOP),简单的说就是一个分层的轻量级开源框架。

① 导入spring框架需要的jar包：

② 创建xml文件，并在配置文件中配置Bean对象：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--  id:给bean设置的唯一标志，可以通过id，找到这个bean对象
      class：类的全名，用于表示bean的类型。
      -->
    <bean id="p1" class="com.hqyj.entity.Phone"></bean>
<!--  创建对象的方式  -->
    <bean id="date" class="java.util.Date"></bean>
    <bean id="cal" class="java.util.Calendar" factory-method="getInstance"></bean>
    <bean id="date1" class="java.util.Date" factory-bean="cal" factory-method="getTime"></bean>
</beans>

注意：在配置bean对象之前我们需要定义一个与之相关的java类。这里我定义一个手机的实体类对象

package com.hqyj.entity;

public class Phone {
    private String pinPai;
    private Double price;
    private Integer mem;

    @Override
    public String toString() {
        return "Phone{" +
                "pinPai='" + pinPai + '\'' +
                ", price=" + price +
                ", mem=" + mem +
                '}';
    }

    public Phone() {
    }

    public Phone(String pinPai, Double price, Integer mem) {
        this.pinPai = pinPai;
        this.price = price;
        this.mem = mem;
    }

    public String getPinPai() {
        return pinPai;
    }

    public void setPinPai(String pinPai) {
        this.pinPai = pinPai;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public Integer getMem() {
        return mem;
    }

    public void setMem(Integer mem) {
        this.mem = mem;
    }
}

③ 在做好准备工作之后，我们就可以创建spring容器对象，从而去使用这个对象。下面是一个测试类，用来测试我们的对象是否可以正常使用。在这里，我们获取对象的方法是使用的是getBean方法。

@Test
public void getPhone(){
// 1. 创建出spring的容器对象
ApplicationContext ac =
new ClassPathXmlApplicationContext("springday1.xml" );
System.out.println("ac:" + ac);
// 2. 通过容器对象，获取bean。
// getBean(bean的id, bean的类型)
// Phone p1 = ac.getBean("p1", Phone.class);
// Object p1 = ac.getBean("p1");// 根据id查找，但是没有设置查找的结果的类型，所以
返回Object.
Phone p1= ac.getBean(Phone.class); //根据bean的类型查找， 如果有多个符合条件的
类型，就出错。
// 3. 使用对象
p1.setPinPai("vivo");
System.out.println(p1.getPinPai());
// *** 类型
System.out.println(Phone.class); //class com.hqyj.entity.Phone
System.out.println(ApplicationContext.class); //interface
org.springframework.context.ApplicationContext
System.out.println(p1.getClass());//class com.hqyj.entity.Phone
// --- 编译的时候 ac看引用的类型，是ApplicationContext接口。
// --- 程序运行的时候， ac看实际指向的对象的类型， 是
ClassPathXmlApplicationContext类
System.out.println(ac.getClass());//class
org.springframework.context.support.ClassPathXmlApplicationContext
// if(p1.getClass()== Phone.class) ： 判断是否为同一种类型
// 4. 容器关闭
}

以上就是spring框架使用的步骤。

2.springMVC的使用：

springMVC的概念：springMVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。SpringMVC是一种web层mvc框架，用于替代servlet（处理|响应请求，获取表单参数，表单校验等。SpringMVC是一个MVC的开源框架，SpringMVC=struts2+spring，springMVC就相当于是Struts2加上Spring的整合。

① 导入springMVC框架需要的jar包：

② 注意，springMVC和spring不同的是，我们需要到springMVC中的web.xml中去配置DispatcherServlet.java这个类

<!-- 1. tomcat容器启动的时候，就初始化DispatcherServlet
2. DispatcherServlet创建对象的时候，就会创建spring的容器对象。
-->
<servlet>
<servlet-name>mvc</servlet-name>
<servletclass>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 通过servlet的初始化参数的配置，指定spring的配置文件的路径-->
Controller（程序员写对应的类） , jsp (程序员写对应的jsp文件)
jsp
ViewResolver的配置： spring.xml
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc1.xml</param-value>
</init-param>
<!-- tomcat容器启动的时候，就初始化对象-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>mvc</servlet-name>
<!-- **DispatcherServlet的路径只能用通配路径 -->
<url-pattern>/</url-pattern>
</servlet-mapping>

③ 之后我们需要去写对应的Controller，jsp文件

Controller：

public class FirstController implements Controller {
@Override
public ModelAndView handleRequest(HttpServletRequest request ,
HttpServletResponse response) throws Exception {
ModelAndView mav = new ModelAndView(); // 自己创建
Map<String, Object> model = mav.getModel(); // 获取到一个map， 把需要转
发到jsp页面的数据，保存在这个map中
model.put("name" , "小红");
mav.setViewName("Hello"); // 设置要转发的jsp的名字
return mav;
}
}

jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${name} , 欢迎使用!
</body>
</html>

④ 在spring.xml文件中做jsp文件路径的配置

<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- suffix: 后缀
prefix:前缀
通过contrller中转发的view的名字， 和这里前缀，后缀做拼接，然后得到jsp页面
的路径。
比如： /WEB-INF/ + Hello + .jsp , 这个就是jsp的路径。
-->
<property name="suffix" value=".jsp"></property>
<property name="prefix" value="/WEB-INF/"></property>
</bean>

⑤ 到spring.xml文件中将Controller类映射为url地址

<!-- bean的配置-->
<bean id="ft" class="com.hqyj.controller.FirstController"></bean>
<bean id="sc" class="com.hqyj.controller.SecondController"></bean>
<!-- Controller对应的请求路径的配置-->
<bean id="handlerMapping"
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<!-- 属性的key 就是请求的url地址， value就是url地址对应要找的
Controller的bean的id .-->
<prop key="first">ft</prop>
<prop key="second">sc</prop>
</props>
</property>
</bean>

3.Mybatis框架的使用：

① 导入jar包

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.30</version>
</dependency>
<!-- mybatis的包-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.10</version>
</dependency>

② 到mapper.xml文件中进行配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 设置控制台日志输出-->
<!-- 配置数据库连接的环境 ： 默认使用id为"development"的环境-->
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/gamedb?serverTimezone=Asia/Shanghai"/>
<property name="username" value="root"/>
2.2实体类和接口
Hero.java
HeroDao.java
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<!-- 引用存在的mapper.xml文件-->
<mappers>
<mapper resource="mapper/HeroMapper.xml"/>
</mappers>
</configuration>

③ 定义实体类和操作数据库的接口

实体类：

package com.hqyj.entity;
import lombok.Data;
import lombok.ToString;
import java.util.Date;
// 属性名和table-hero的字段名完全一样。
@Data
@ToString
public class Hero {
private Integer id;
private String name;
private String sex;
private String position;
private Integer price;
private Date shelf_date;
}

操作数据库的接口（dao）：

package com.hqyj.dao;
import com.hqyj.entity.Hero;
import java.util.List;
// 定义数据库操作的方法
public interface HeroDao {
public abstract int addHero(Hero hero);
public abstract int deleteHero(Integer id);
public abstract int updateHero(Hero hero);
public abstract List<Hero> queryAll();
}

④ 到Mybatis-config.xml中引用我们的mapper.xml

<mappers>
<mapper resource="mapper/HeroMapper.xml"/>
</mappers>

注意：我们需要在resource目录中创建一个文件夹mapper。专门用于存放mapper.xml

⑤ 编写mapper.xml

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace: 命名空间 , 设置mapper.xml文件中的sql 对应的 interface。 -->
<mapper namespace="com.hqyj.dao.HeroDao">
<!-- insert:表示这是一个插入的sql语句
id: 对应dao(interface)中方法的名字
parameterType: 设置的dao(interface)中方法的参数
insert标签的内部： sql语句
sql语句中的#{属性名} ， 就是在获取参数对象的属性的值 -->
<insert id="addHero" parameterType="com.hqyj.entity.Hero">
insert into hero values(null, #{name} , #{sex}
, #{position} , #{price} , #{shelf_date})
</insert>
<!-- 方法的参数是一个，并且属于8种类型 ，就可以省略。
也可以设置parameterType="int" ，这里的int就是简写
#{id} ，这里的id和方法参数名完全一致， deleteHero(Integer id)-->
<delete id="deleteHero">
delete from hero where id = #{id}
</delete>
<!-- price=#{price} ， price是列名（table的列名），
#{price}(实体类的属性） ,这里是属性值的获取。-->
<update id="updateHero" parameterType="com.hqyj.entity.Hero">
update hero set `name` = #{name} , sex=#{sex},
`position` =#{position } , price=#{price} ,
shelf_date=#{shelf_date} where id=#{id}
</update>
<!-- resultType="com.hqyj.entity.Hero"：返回值是一个实体，或者泛型为实体的集
合，
设置的返回值类型都是这个实体类。-->
<select id="queryAll" resultType="com.hqyj.entity.Hero">
select * from hero
</select>
</mapper>

⑥ 测试功能：

public class AppTest
{
SqlSession sqlSession;
// HeroDao --> SqlSession --> SqlSessionFactory ---> io(mybatisconfig.xml)
@Before
public void createSession() throws Exception{
String location = "mybatis-config.xml"; // mybatis配置文件的路径
InputStream resourceAsStream =
Resources.getResourceAsStream(location);
// 创建session工厂类
SqlSessionFactory sqlSessionFactory =
new SqlSessionFactoryBuilder().build(resourceAsStream);
// 获取session对象
sqlSession = sqlSessionFactory.openSession();
}
@After
public void closeAndCommit(){
sqlSession.commit(); // 提交 (更新必须提交 ，不然数据库并不会写入)
sqlSession.close();
}
@Test
public void testQuery()
{
HeroDao dao = sqlSession.getMapper(HeroDao.class);
// ---- 编译的时候是引用类型 ， 运行的时候是实际类型
System.out.println("dao:" + dao.getClass());
dao.queryAll();
}
}

4.springBoot+Mybatis-plus的使用：

springBoot的概念：springboot是一个微服务框架，延续了spring框架的核心思想IOC和AOP，简化了应用的开发和部署。Spring Boot是为了简化Spring应用的创建、运行、调试、部署等而出现的，使用它可以做到专注于Spring应用的开发，而无需过多关注XML的配置。提供了一堆依赖打包，并已经按照使用习惯解决了依赖问题—>习惯大于约定。

① 导包

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<!-- mybatis-spring-boot-starter -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.2.1</version>
</dependency>

② 文件的配置：

#数据源的设置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/empdb?
serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=123456
#数据源的配置 (druid的数据源)
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
#mapper.xml的路径
mybatis.mapper-locations=classpath:mapper/*.xml
#日志输出
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
mapper.java包扫描的设置
@MapperScan("com.hqyj.sbm.dao")
@Mapper（在每个mapper.java类之前添加）
测试类的使用: 需要导入spring-boot-starter-test包
service中的使用
#server的配置
server.port=8080

③ 导入mybatis plus的包

<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.2</version>
</dependency>

④ mybatis plus的自动生成先导包

<!-- mybatis plus 自动生成-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.5.3</version>
</dependency>
<!-- freemarker的包-->
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>2.3.31</version>
</dependency>
<!-- swagger的包-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-boot-starter</artifactId>
<version>3.0.0</version>
</dependency>

⑤ 编写生成类

public class GenMyBatisPlus {
public static void main(String[] args) {
FastAutoGenerator.create("jdbc:mysql://localhost:3306/empdb?
serverTimezone=Asia/Shanghai",
"root", "123456")
.globalConfig(builder -> {
builder.author("fengjm") // 设置作者
.enableSwagger() // 开启 swagger 模式
.fileOverride() // 覆盖已生成文件
.outputDir("D:/javaweb/sbmp/src/main/java"); // 指定输
出目录
})
3.3测试功能
4. mybatis plus的分页查询
分页的拦截器的配置
测试分页的功能
.packageConfig(builder -> {
builder.parent("com.hqyj.sbmp") // 设置父包名
// .moduleName("emp") // 设置父包模块名
.pathInfo(Collections.singletonMap(OutputFile.xml,
"D://")); // 设置mapperXml生成路径
})
.strategyConfig(builder -> {
builder.addInclude("emp" ,"user" , "dept") // 设置需要生成的表名
.addTablePrefix("t_", "c_"); // 设置过滤表前缀
})
.templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker
引擎模板，默认的是Velocity引擎模板
.execute();
}
}

⑥ 运行生成类，并进行测试。

值得一提的是，mybatis-plus为我们封装好了对应的crud方法，我们在使用的时候只需要去调用就行，和mybatis相比，省去了我们要去写sql语句。极大程度上的简化了我们的代码。