前置文章：
前言：
前置文章中我们已经介绍了基础JPA的使用方式，JPA是操作数据库的一种ORM规范，而文章中使用的Hibernate是其具体的实现。
本文则是使用Spring Data JPA来进行具体的CRUD操作。
一、基础准备
二、基础CRUD
三、JPQL形式查询
四、SQL形式查询
五、方法命名规则查询
<!--属性控制-->
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<spring.version>5.1.20.RELEASE</spring.version>
<hibernate.version>5.0.7.Final</hibernate.version>
<javax.el.version>2.2.4</javax.el.version>
<slf4j.version>1.6.6</slf4j.version>
</properties>
此处依赖部分并没有过多说明，因为现在大家使用的Spring Boot、Spring Cloud都在淡化我们依赖配置的内容，更关注代码开发本身。
<!--依赖管理-->
<dependencies>
<!--Junit-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--Spring-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.0</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.9.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<!--el-->
<dependency>
<groupId>javax.el</groupId>
<artifactId>javax.el-api</artifactId>
<version>${javax.el.version}</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>javax.el</artifactId>
<version>${javax.el.version}</version>
</dependency>
<!--hibernate-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.2.1.Final</version>
</dependency>
<!--MySQL-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.30</version>
</dependency>
<!--c3p0数据库连接池-->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<!--log-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
</dependencies>
引入了beans、aop、context、jdbc、tx、jpa这些命名空间。
<?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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
</beans>
<!-- 1. 创建数据库连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql:///test"/>
<property name="user" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- 2. 创建entityManagerFactory对象 -->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<!-- ① 配置数据源 -->
<property name="dataSource" ref="dataSource"/>
<!-- ② 指定实体类所在的包 -->
<property name="packagesToScan" value="com.stone.domain"/>
<!-- ③ 配置JPA的实现厂商（供应商） -->
<property name="persistenceProvider">
<bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
</property>
<!-- ④ JPA的供应商适配器 -->
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!-- a、配置是否自动创建数据库表 -->
<property name="generateDdl" value="false"/>
<!-- b、指定数据库类型 -->
<property name="database" value="MYSQL"/>
<!-- c、数据库方言：支持的特有语法，MySQL分页limit，Oracle分页ROWNUM -->
<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
<!-- d、是否显示SQL语句 -->
<property name="showSql" value="true"/>
</bean>
</property>
<!--⑤ JPA方言：高级特性-->
<property name="jpaDialect">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
</property>
</bean>
<!-- 3. 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>
<!-- 4. 整合Spring Data JPA -->
<jpa:repositories base-package="com.stone.dao" transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactory"/>
此处非必要
<!-- txAdvice -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save" propagation="REQUIRED"/>
<tx:method name="insert" propagation="REQUIRED"/>
<tx:method name="update" propagation="REQUIRED"/>
<tx:method name="delete" propagation="REQUIRED"/>
<tx:method name="get*" read-only="true"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- aop -->
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* com.stone.service.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
</aop:config>
<context:component-scan base-package="com.stone"/>
此处暂时没有。
/**
* 客户实体类
* → 配置映射关系
* 1. 实体类和表的映射关系；
* 2. 实体类中属性和表中字段的映射关系；
* → 实体类和表的映射关系
* ① @Entity：声明实体类；
* ② @Table：配置实体类和表的映射关系；
* → name：配置数据库表名称；
* → 实体类中属性和表中字段的映射关系
* ① @Id：声明主键的配置；
* ② @GeneratedValue：配置主键生成策略；
* → strategy：主键策略
* a、 GenerationType.IDENTITY 自增，MySQL数据库；
* 底层数据库必须支持自动增长，采用数据库自增方式对ID进行自增。
* b、 GenerationType.SEQUENCE 序列，Oracle数据库；
* 底层数据库支持序列。
* c、 GenerationType.TABLE
* JPA提供的一种机制，通过一张数据库表的形式帮助完成主键自增。
* d、 GenerationType.AUTO
* 由程序自动选择主键生成策略。
* ③ Column：实体类属性与表字段映射
* → name：数据库表字段名称
*/
@Table(name = "cst_customer")
@Entity
public class Customer {
/*客户主键*/
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "cust_id")
private Long custId;
/*客户名称*/
@Column(name = "cust_name")
private String custName;
/*客户资源来源*/
@Column(name = "cust_source")
private String custSource;
/*客户级别*/
@Column(name = "cust_level")
private String custLevel;
/*客户所属行业*/
@Column(name = "cust_industry")
private String custIndustry;
/*客户的联系方式*/
@Column(name = "cust_phonoe")
private String custPhone;
/*客户地址*/
@Column(name = "cust_address")
private String custAddress;
...
}
NOTE
JpaRepository<T, ID>，该接口封装了基础CRUD操作：
→ T：操作的实体类类型；
→ ID：实体类中主键属性的类型。JpaSpecificationExecutor<T>，该接口封装了复杂查询（分页）：
→ T：操作的实体类类型。
/**
* 符合SpringDataJpa规范的接口
* → JpaRepository<T, ID>，该接口封装了基础CRUD操作
* T：操作的实体类类型；
* ID：实体类中主键属性的类型。
* → JpaSpecificationExecutor<T>，该接口封装了复杂查询（分页）
* T：操作的实体类类型。
*/
public interface CustomerDao extends JpaRepository<Customer, Long>,
JpaSpecificationExecutor<Customer> {
...
}
@RunWith(SpringJUnit4ClassRunner.class) //声明Spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml") //指定Spring容器配置信息
public class CustomerDaoTest {
@Autowired
private CustomerDao customerDao;
...
}
NOTE
findOne → em.find() → 立即加载；
getOne → em.getReference() → 延迟加载；
/**
* 测试跟据ID查询，findOne方法
*/
@Test
public void testFindOne() {
Customer customer = customerDao.findOne(1L);
System.out.println(customer);
}
/**
* 跟据ID从数据库查询，getOne方法需要使用@Transactional注解
* findOne → em.find()：立即加载
* getOne → em.getReference()：延迟加载
*/
@Test
@Transactional
public void testGetOne() {
Customer customer = customerDao.getOne(5L);
System.out.println(customer);
}
NOTE
① 实体对象未设置主键属性值：直接保存；
② 实体对象设置主键属性值：
→ a、主键存在，进行更新；
→ b、主键不存在，跟据主键策略生成主键进行插入(保存)。
/**
* 测试更新|保存，save方法
* → 先查询，后更新|保存
* 如果没有设置ID属性，则进行保存操作；如果设置了ID属性，则会进行更新|保存。
* ① 如果指定ID数据存在，则进行更新操作；
* ② 如果指定ID数据不存在，则进行保存操作（注意：保存时主键会依据主键策略自动生成，而不是指定的主键）。
*/
@Test
public void testSave() {
Customer customer = new Customer();
customer.setCustId(22L);
customer.setCustName("Stone");
customerDao.save(customer);
}
/**
* 测试删除delete
* → 先查询，后删除
*/
@Test
public void testDelete() {
customerDao.delete(21L);
}
/**
* 测试查询所有findAll
*/
@Test
public void testFindAll() {
List<Customer> customers = customerDao.findAll();
for (Customer customer : customers) {
System.out.println(customer);
}
}
/**
* 测试聚合（统计）查询
*/
@Test
public void testCount() {
long count = customerDao.count();
System.out.println(count);
}
/**
* 测试查询判断是否存在
* 传统方式：
* ① 判断查询结果是否为空null；
* ② 判断查询结果条数是否大于0；【JPA采用此方式】
*/
@Test
public void testExists() {
boolean exists = customerDao.exists(4L);
System.out.println(exists);
}
/**
* 跟据客户名称查询客户信息
* JPQL：FROM Customer WHERE custName = ?
* 注意：在@Query注解的value属性中，需要使用"?1"来指定具体占位。
*
* @param custName 客户名称
* @return 客户信息
*/
@Query(value = "FROM Customer WHERE custName = ?1")
public Customer findJpql(String custName);
/**
* 测试JPQL查询
*/
@Test
public void testJpql() {
Customer yinRui = customerDao.findJpql("Yin Rui");
System.out.println(yinRui);
}
/**
* JPQL：FROM Customer WHERE custName = ? AND custId = ?
*
* @param custName 客户名称
* @param custId 客户ID
* @return 客户信息
*/
@Query(value = "FROM Customer WHERE custName = ?1 AND custId = ?2")
public Customer findCustNameAndCustId(String custName, Long custId);
/**
* 测试JPQL多条件查询
*/
@Test
public void testJpqlAnd() {
Customer nicholasDunn = customerDao.findCustNameAndCustId("Nicholas Dunn", 19L);
System.out.println(nicholasDunn);
}
NOTE
相比于查询方法，此处需要配合 @Modifying 注解一起使用。
/**
* 更新客户姓名（@Query：代表进行查询；@Modifying：代表当前执行方法进行更新操作。）
* SQL：UPDATE cst_customer SET cust_name = ? WHERE cust_id = ?
* JPQL：UPDATE Customer SET custName = ? WHERE custId = ?
*
* @param custName
* @param custId
*/
@Query(value = "UPDATE Customer SET custName = ?1 WHERE custId = ?2")
@Modifying //(@Modifying+@Query)一起使用，代表更新操作。
public void updateCustomer(String custName, Long custId);
/**
* 测试JPQL更新操作
* → SpringDataJpa中使用jpql完成 更新|删除操作 需要手动添加事务支持；
* → 在@Test注解下，默认SpringDataJpa执行完成会进行数据回滚；
* → 使用@Rollback(value = false)，关闭自动回滚。
*/
@Test
@Transactional //添加事务支持
@Rollback(value = false)
public void testUpdate() {
customerDao.updateCustomer("Jeff Stone", 1L);
}
/**
* SQL：SELECT * FROM cst_customer
* → 使用@Query注解，配置：
* ① value属性：sql；
* ② nativeQuery属性：使用本地sql查询，true；反之，false。
*
* @return 查询对象集合
*/
@Query(value = "SELECT * FROM cst_customer", nativeQuery = true)
public List<Object[]> findSql();
/**
* 测试使用本地SQL查询全部客户信息
*/
@Test
public void testSql() {
List<Object[]> objects = customerDao.findSql();
for (Object[] object : objects) {
System.out.println(Arrays.toString(object));
}
}
/**
* 使用SQL查询，进行模糊匹配
* SQL：SELECT * FROM cst_customer WHERE cust_name LIKE ?
*
* @param custName 客户名称
* @return 客户信息
*/
@Query(value = "SELECT * FROM cst_customer WHERE cust_name LIKE ?1", nativeQuery = true)
public List<Object[]> findSqlLike(String custName);
/**
* 测试SQL查询，模糊匹配
*/
@Test
public void testSqlLike() {
List<Object[]> objects = customerDao.findSqlLike("%Hicks");
for (Object[] object : objects) {
System.out.println(Arrays.toString(object));
}
}
NOTE
查询方法写法：findBy + 属性名称(field_name)，等值匹配
/**
* 方法命名规则查询，是对JPQL查询的更深层的封装，使用该规则可以不用再写JPQL语句。
* → 查询方法写法：findBy + 属性名称(field_name)，等值匹配
* ① 以findBy开头；
* ② 拼接对象中的属性，属性首字母改为大写；
*
* @param custName 客户名称
* @return 客户信息
*/
public Customer findByCustName(String custName);
/**
* 测试按照方法命名规则查询
*/
@Test
public void testFindByCustName() {
Customer itoRiku = customerDao.findByCustName("Ito Riku");
System.out.println(itoRiku);
}
NOTE
查询方法写法：findBy + 属性名称(field_name) + 查询方式[Like|Isnull]
/**
* 跟据方法命名规则，进行模糊匹配
* → 查询方法写法：findBy + 属性名称(field_name) + 查询方式[Like|Isnull]
*
* @param custName 客户名称
* @return 客户信息
*/
public List<Customer> findByCustNameLike(String custName);
/**
* 测试模糊匹配查询（注意：由于时占位符的形式进行填充，"%"的位置信息需要自己判断。）
*/
@Test
public void testFindByCustNameLike() {
List<Customer> customers = customerDao.findByCustNameLike("%Yuito");
for (Customer customer : customers) {
System.out.println(customer);
}
}
NOTE
查询方法写法：findBy + 属性名称(field_name) + 查询方式[Like|Isnull] + 多条件连接符(And|Or) + 属性名称(field_name) + 查询方式[Like|Isnull]
/**
* 跟据方法命名规则，进行多条件查询
* → 查询方法写法：findBy + 属性名称(field_name) + 查询方式[Like|Isnull] + 多条件连接符(And|Or)
* + 属性名称(field_name) + 查询方式[Like|Isnull]
*
* @param CustName 客户名称
* @param CustAddress 客户地址
* @return 客户信息
*/
public List<Customer> findByCustNameLikeAndCustAddress(String CustName, String CustAddress);
/**
* 测试多条件查询
*/
@Test
public void testFindByCustNameLikeAndCustAddress() {
List<Customer> customers =
customerDao.findByCustNameLikeAndCustAddress("Xue%", "536 Wall Street");
for (Customer customer : customers) {
System.out.println(customer);
}
}
以上即为Spring Data JPA-基础篇（二）的全部内容，感谢阅读。
1.postman介绍Postman一款非常流行的API调试工具。其实，开发人员用的更多。因为测试人员做接口测试会有更多选择，例如Jmeter、soapUI等。不过，对于开发过程中去调试接口，Postman确实足够的简单方便，而且功能强大。2.下载安装官网地址:https://www.postman.com/下载完成后双击安装吧，安装过程极其简单，无需任何操作3.使用教程这里以百度为例,工具使用简单，填写URL地址即可发送请求，在下方查看响应结果和响应状态码常用方法都有支持请求方法:getpostputdeleteGet、Post、Put与Delete的作用get：请求方法一般是用于数据查询，
Ⅰ软件测试基础一、软件测试基础理论1、软件测试的必要性所有的产品或者服务上线都需要测试2、测试的发展过程3、什么是软件测试找bug，发现缺陷4、测试的定义使用人工或自动的手段来运行或者测试某个系统的过程。目的在于检测它是否满足规定的需求。弄清预期结果和实际结果的差别。5、测试的目的以最小的人力、物力和时间找出软件中潜在的错误和缺陷6、测试的原则28原则：20%的主要功能要重点测（eg：支付宝的支付功能，其他功能都是次要的）80%的错误存在于20%的代码中7、测试标准8、测试的基本要求功能测试性能测试安全性测试兼容性测试易用性测试外观界面测试可靠性测试二、质量模型衡量一个优秀软件的维度①功能性功
ES一、简介1、ElasticStackES技术栈：ElasticSearch：存数据+搜索；QL；Kibana：Web可视化平台，分析。LogStash：日志收集，Log4j:产生日志；log.info(xxx)。。。。使用场景：metrics：指标监控…2、基本概念Index（索引）动词：保存（插入）名词：类似MySQL数据库，给数据Type（类型）已废弃，以前类似MySQL的表现在用索引对数据分类Document（文档）真正要保存的一个JSON数据{name:"tcx"}二、入门实战{"name":"DESKTOP-1TSVGKG","cluster_name":"elasticsear
（本文是网络的宏观的概念铺垫）目录计算机网络背景网络发展认识"协议"网络协议初识协议分层OSI七层模型TCP/IP五层(或四层)模型报头以太网碰撞路由器IP地址和MAC地址IP地址与MAC地址总结IP地址MAC地址计算机网络背景网络发展 是最开始先有的计算机，计算机后来因为多项技术的水平升高，逐渐的计算机变的小型化、高效化。后来因为计算机其本身的计算能力比较的快速：独立模式：计算机之间相互独立。 如：有三个人，每个人做的不同的事物，但是是需要协作的完成。 而这三个人所做的事是需要进行协作的，然而刚开始因为每一台计算机之间都是互相独立的。所以前面的人处理完了就需要将数据
文章目录概念索引相关操作创建索引更新副本查看索引删除索引索引的打开与关闭收缩索引索引别名查询索引别名文档相关操作新建文档查询文档更新文档删除文档映射相关操作查询文档映射创建静态映射创建索引并添加映射概念es中有三个概念要清楚，分别为索引、映射和文档（不用死记硬背，大概有个印象就可以）索引可理解为MySQL数据库；映射可理解为MySQL的表结构；文档可理解为MySQL表中的每行数据静态映射和动态映射上面已经介绍了，映射可理解为MySQL的表结构，在MySQL中，向表中插入数据是需要先创建表结构的；但在es中不必这样，可以直接插入文档，es可以根据插入的文档（数据），动态的创建映射（表结构），这就
目录1关系运算符2运算符优先级3关系表达式的书写代码实例：下面是面试中可能遇到的问题：1关系运算符C++中有6个关系运算符，用于比较两个值的大小关系，它们分别是：运算符描述==等于!=不等于小于>大于小于等于>=大于等于这些运算符返回一个布尔值，即true或false。例如，当x等于y时，x==y的结果为true，否则结果为false。2运算符优先级在C++中，关系运算符的优先级高于赋值运算符，但低于算术运算符。以下是关系运算符的优先级，从高到低排列：运算符描述>,,>=,关系运算符==,!=相等性运算符&&逻辑与`如果在表达式中有多个运算符，则按照优先级顺序依次进行运算。3关系表达式的书写在
一.计算机组成原理 这本书利用组合逻辑、同步时序逻辑电路设计的相关知识，从逻辑门开始逐步构建运算器、存储器、数据通路和控制器，最终集成为完整的CU原型系统，使读者从设计者的角度理解计算机部件构成及运行的基本原理，掌握软硬件协同的概念。 全书共9章，主要内容包括计算机系统概述、数据信息的表示、运算方法与运算器、存储系统、指令系统、中央处理器、指令流水线、总线系统、输入输出系统。1.计算机系统概述1.1计算机发展历程 计算机是一种能够按照事先存储的程序，自动、高速、准确地对相关信息进行处理的电子设备。1946年2月，世界上第一台电子数字计算机ENIAC(ElectronicNum
其实现在基础的资料和视频到处都是，就是看你有没有认真的去找学习资源了，去哪里学习都是要看你个人靠谱不靠谱，再好的教程和老师，你自己学习不进去也是白搭在正式选择之前，大可以在各种学习网站里面找找学习资源先自己学习一下为什么选择学软件测试？同学们理由众多！大概分这几类：①不受开发语言、行业产品变化限制；②入门更简单，对零基础、女生都友好；③软件项目都需要测试人员，职业生涯稳；④学习周期短，但薪资并不低。要想“肩扛”一条线？需掌握三大技能：技能1：掌握测试流程，熟悉系统框架能提前与开发人员一起制定测试计划，通过测试左移，推动代码评审，代码审计，单元测试，自动化冒烟测试，来保证研发阶段的质量。技能2：
Asitcurrentlystands,thisquestionisnotagoodfitforourQ&Aformat.Weexpectanswerstobesupportedbyfacts,references,orexpertise,butthisquestionwilllikelysolicitdebate,arguments,polling,orextendeddiscussion.Ifyoufeelthatthisquestioncanbeimprovedandpossiblyreopened,visitthehelpcenter提供指导。已关闭8年。什么是学习ruby语言
html基础标签学习网站：https://www.acwing.com/学习查询网站：https://developer.mozilla.org/zh-CN/!+tab自动出现框架1.1文档结构html的所有标签都为树形结构，例如：Web应用课第一讲html标签HTML元素表示一个HTML文档的根（顶级元素），所以它也被称为根元素。所有其他元素必须是此元素的后代。head标签HTML元素规定文档相关的配置信息（元数据），包括文档的标题，引用的文档样式和脚本等。body标签HTML元素表示文档的内容。document.body属性提供了可以轻松访问文档的body元素的脚本。title标签HTML