1. 全栈程序员必看首页

Hibernate框架–学习笔记（上）：hibernate项目的搭建和常用接口方法、对象的使用

全栈程序员-用户IM • • 未分类

Hibernate框架–学习笔记（上）：hibernate项目的搭建和常用接口方法、对象的使用

一、什么是Hibernate框架：

1.Hibernate是一个操作数据库的框架，实现了对JDBC的封装；

2.Hibernate是一个ORM（对象关系映射）框架，我们在写程序时 ，用的是面向对象的方法，但是在关系型数据库里，存的是一条条的数据，为了用纯面向对象的思想解决问题，所有需要将程序中的对象和数据库的记录建立起映射关系，ORM就是这样的技术，而Hibernate就是这样一个框架，以操作对象的方式操作数据库。

3.Hibernate简化了代码的编写，原生态的JDBC需要很多代码来实现操作数据库，在这里用Hibernate只需要很少的代码就可以实现。

4.使用Hibernate的基本流程是：配置实现类与数据库表的映射关系，产生sessionFactory，打开session通道拿到session对象，开启事务，完成操作，关闭session。

5.Hibernate屏蔽了数据库的差异，增强了对数据库的可移植性。

6.使用Hibernate时，先要配置hibernate.cfg.xml文件，其中配置数据库连接信息和方言等，还要为每个实体配置相应的hbm.xml文件（Hibernate的映射文件），当然，也可以采用注解编程实现映射关系，hibernate.cfg.xml文件中需要登记每个hbm.xml文件。

 

二、Hibernate项目的基本搭建：

步骤：

–创建工程，导入依赖；

–创建Hibernate核心配置文件；

–创建持久化类；

–创建对象-关系映射文件；

–通过Hibernate API编写访问数据库的代码。

 

具体实现：

1、创建一个maven项目，在pom.xml文件中导入hibernate所有相关的jar包依赖：

为了方便，在这里我直接导入ssh整合项目常用的依赖。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.zwp</groupId>
	<artifactId>ssh-test</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<!-- 属性 -->
	<properties>
		<spring.version>4.2.4.RELEASE</spring.version>
		<hibernate.version>5.0.7.Final</hibernate.version>
		<struts.version>2.3.24</struts.version>
	</properties>

	<!-- 锁定版本，struts2-2.3.24、spring4.2.4、hibernate5.0.7 -->
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-context</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-aspects</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-test</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-web</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.hibernate</groupId>
				<artifactId>hibernate-core</artifactId>
				<version>${hibernate.version}</version>
			</dependency>
			<dependency>
				<groupId>org.apache.struts</groupId>
				<artifactId>struts2-core</artifactId>
				<version>${struts.version}</version>
			</dependency>
			<dependency>
				<groupId>org.apache.struts</groupId>
				<artifactId>struts2-spring-plugin</artifactId>
				<version>${struts.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<!-- 依赖管理 -->
	<dependencies>
		<!-- spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
		</dependency>

		<!-- 导入 struts2 -->
		<dependency>
			<groupId>org.apache.struts</groupId>
			<artifactId>struts2-core</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.struts</groupId>
			<artifactId>struts2-spring-plugin</artifactId>
		</dependency>

		<!-- hibernate -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
		</dependency>

		<!-- 数据库驱动 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.6</version>
			<scope>runtime</scope>
		</dependency>
		<!-- c3p0 -->
		<dependency>
			<groupId>c3p0</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.1.2</version>
		</dependency>

		<!-- servlet jsp -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.0</version>
			<scope>provided</scope>
		</dependency>

		<!-- 日志 -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.2</version>
		</dependency>
		<!-- junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.9</version>
			<scope>test</scope>
		</dependency>
		<!-- jstl -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<!-- 设置编译版本为1.8 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			
				<!-- 默认的tomcat6不支持jdk1.8，访问页面时报错：页面编译成.class失败
				 解决：配置tomcat7插件：mvn命令改为：tomcat7:run -->
			<plugin>
				<groupId>org.apache.tomcat.maven</groupId>
				<artifactId>tomcat7-maven-plugin</artifactId>
				<version>2.2</version>
				<configuration>
					<url>http://127.0.0.1:8080/manager/text</url>
					<server>tomcat8</server>
					<path>/</path>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

2、创建Hibernate的主配置文件，命名：hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
	
		<!-- 连接数据库 -->
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql:///ssh-test</property>
		<property name="connection.username">root</property>
		<property name="connection.password">admin</property>
		
		<!-- 设置数据库方言 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
		<!-- 输出底层sql语句 -->
		<property name="hibernate.show_sql">true</property>
		<!-- format输出的底层sql语句格式 -->
		<property name="hibernate.format_sql">true</property>
		<!-- 自动创建表；update:如果已经有表，更新，如果没有，创建 -->
		<property name="hibernate.hbm2ddl.auto">update</property>
		
		<!-- 把映射文件放到核心配置文件中 -->
		<mapping resource="com/zwp/domain/User.hbm.xml" />
	</session-factory>
</hibernate-configuration>

3、创建持久化类：

//持久化对象：
public class User {

	private int uid;
	private String username;
	private String password;
	private String address;
	
	public int getUid() {
		return uid;
	}
	public void setUid(int uid) {
		this.uid = uid;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
}

4、创建对象-关系映射文件：命名：类名.hbm.xml

并把映射文件放到核心配置文件hibernate.cfg.xml中，在第二步中已经写出来了。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<!-- 创建映射配置文件 -->
<hibernate-mapping>
	<!-- 1.配置类和对应表 class标签：name属性：实体类全路径；table属性：数据库表名称，数据库需要自己建立，如果不建立，会报异常 -->
	<class name="com.zwp.domain.User" table="t_user">
	
		<!-- 2.配置实体类id和表id对应，
		hibernate要求实体类有一个属性唯一致，hibernate要求表有字段作为唯一值 -->
		
		<!-- id标签：name属性：实体类里面id属性名称；column属性：生成的表字段名称 -->
		<id name="uid" column="uid">
			<!-- 设置uid的增长策略；native:就是生成表id主键自动增长,实体类的主键类型是int类型-->
			<generator class="native"></generator>		
		
			<!-- 设置uid的增长策略；uuid:就是生成表id随机uuid,实体类的主键类型是String类型-->
			<!-- <generator class="uuid"></generator> -->
		</id>
		
		<!-- 3.配置其他属性和表字段对应；name属性：实体类属性名称；column属性:生成表字段名称 -->
		<property name="username" column="username"></property>
		<property name="password" column="password"></property>
		<property name="address" column="address"></property>
	</class>
</hibernate-mapping>

5、测试：

//Hibernate的测试类
public class HibernateTest {

    //添加一条数据的测试
	@Test
	public void testAdd(){
		//第一步：加载hibernate核心配置文件
		Configuration cfg=new Configuration();
		cfg.configure();
		
		//第二步：建立sessionFactory
		//读取hibernate核心配置文件的内容，创建sessionFactory
		//在这个过程中，会根据映射关系，在配置数据里面把表创建
		SessionFactory sessionFactory = cfg.buildSessionFactory();
		
		//第三步：使用SessionFactory常见session对象
		Session session = sessionFactory.openSession();
		
		//第四步：开启事务：
		Transaction tx = session.beginTransaction();
		
		//第五步：写具体的逻辑crud操作：
		//添加功能：
		User user = new User();
		user.setUsername("zhangweipeng");
		user.setPassword("123456");
		user.setAddress("中国");
		session.save(user);
		
		//第六步：提交事务
		tx.commit();
		
		//第七步：关闭资源
		session.close();
		sessionFactory.close();
	}
}

至此，如果测试成功的话，那么一个简单的hibernate的项目已经搭建完成。

附：项目结构：

Hibernate框架--学习笔记（上）：hibernate项目的搭建和常用接口方法、对象的使用

 

三、常用Hibernate方法的使用：

1、hibernate常用方法：

//Hibernate的测试类
public class HibernateTest {

	@Test
	public void testAdd(){
		//第一步：加载hibernate核心配置文件
		Configuration cfg=new Configuration();
		cfg.configure();
		
		//第二步：建立sessionFactory
		//读取hibernate核心配置文件的内容，创建sessionFactory
		//在这个过程中，会根据映射关系，在配置数据里面把表创建
		SessionFactory sessionFactory = cfg.buildSessionFactory();
		
		//第三步：使用SessionFactory常见session对象
		Session session = sessionFactory.openSession();
		
		//第四步：开启事务：
		Transaction tx = session.beginTransaction();
		
		//第五步：写具体的逻辑crud操作之添加功能：
		User user = new User();
		user.setUsername("zhangweipeng");
		user.setPassword("123456");
		user.setAddress("中国");
		session.save(user);
		
		//第六步：提交事务
		tx.commit();
		
		//第七步：关闭资源
		session.close();
		sessionFactory.close();
	}
	
	@Test
	public void testSel(){
		Configuration cfg=new Configuration();
		cfg.configure();
		SessionFactory sessionfactory=cfg.buildSessionFactory();
		Session session=sessionfactory.openSession();
		Transaction tx=session.beginTransaction();
		
		//第五步：写具体逻辑crud操作之查询功能:
		//调用session的get方法,第一个参数:实体类class;第二个参数:id值
		User user=session.get(User.class, 1);
		System.out.println(user.toString());
		
		tx.commit();
		session.close();
		sessionfactory.close();	
	}
	
	@Test
	public void testUpadte(){
		Configuration cfg=new Configuration();
		cfg.configure();
		SessionFactory sessionfactory=cfg.buildSessionFactory();
		Session session=sessionfactory.openSession();
		Transaction tx=session.beginTransaction();
		
		//第五步：写具体逻辑crud操作之修改功能：
		//5.1根据id进行查询
		User user=session.get(User.class, 1);
		//5.2设置修改值
		user.setUsername("updateUsername");
		//调用session的update修改；持久态会自动更新数据库，可以不调用update 
		//session.update(user);
		
		tx.commit();
		session.close();
		sessionfactory.close();	
	}
	
	
	@Test
	public void testDel(){
		Configuration cfg=new Configuration();
		cfg.configure();
		SessionFactory sessionfactory=cfg.buildSessionFactory();
		Session session=sessionfactory.openSession();
		Transaction tx=session.beginTransaction();
		
		//第五步：写具体逻辑crud操作之删除功能:
		//常用：1:根据id删除
		User user=session.get(User.class, 2);
		session.delete(user);
		
		//不常用：
		//User user=new User();
		//user.setUid(4);
		//session.delete(user);
		
		tx.commit();
		session.close();
		sessionfactory.close();
	}
	
	//saveOrUpdate()方法的使用
	@Test
	public void testsavaOrUpdate(){
		Configuration cfg=new Configuration();
		cfg.configure();
		SessionFactory sessionfactory=cfg.buildSessionFactory();
		Session session=sessionfactory.openSession();
		Transaction tx=session.beginTransaction();
		
//		瞬时态的情况：
//		User user =new User();
//		user.setUsername("张三");
//		user.setPassword("5646548");
//		user.setAddress("中国");
//		//实体类对象的状态是瞬时态，则执行添加操作
//		session.saveOrUpdate(user);
		
//		持久态的情况：
//		User user=session.get(User.class, 1);
//		user.setUsername("李四");
//		//实体类对象的状态是持久态，则执行修改操作
//		session.saveOrUpdate(user);
		
		//托管态的情况：
		User user=new User();
		user.setUid(6);
		user.setUsername("王五");
		user.setPassword("132156");
		user.setAddress("印度");
		//实体类对象的状态是托管态，则执行修改操作
		session.saveOrUpdate(user);
		
		tx.commit();
		session.close();
		sessionfactory.close();
	}
}

hibernate中实体类对象有三种状态：

（1）瞬时态：实体类对象没有id值，与session也没有关联

（2）持久态：实体类对象有id值，与session有关联

（3）托管态：实体类对象有id值，与session没有关联

2、封装工具类：

从上面的几个测试方法可以看出，我们一直在重复使用同一段代码去创建并获取session，开启事务，为了提高代码的利用率，我们将重复使用的代码抽取出来，封装成一个工具类。

//Hibernate的util工具类：
public class HibernateUtil {
	
	static Configuration cfg=null;
	static SessionFactory sessionfactory=null;
	
	//静态代码块实现
	static{
		//加载核心配置文件
		cfg=new Configuration();
		cfg.configure();
		sessionfactory=cfg.buildSessionFactory();
	}
	
	//提供返回与本地线程的session方法
        //需要在hibernate.cfg.xml中加入下面配置
        //<property name="hibernate.current_session_context_class">thread</property>
	public static Session getSeesionObject()
	{
		return sessionfactory.getCurrentSession();
	}
	
	//提供方法返回sessionFactory
	public static SessionFactory getSessionFactory()
	{
		return sessionfactory;
	}
}

3、hibernate的规范写法：

        //hibernate规范写法：
	@Test
	public void test(){
		//得到与本地连接的session
		Session session = null;
		Transaction tx=null;
		
		try
		{
			//与本地线程绑定的session
			session=HibernateUtil.getSeesionObject();
			tx=session.beginTransaction();
			
			User user=new User();
			user.setUsername("张维鹏");
			user.setPassword("123");
			user.setAddress("中国");
			session.save(user);
			
			tx.commit();	
		}catch(Exception e){
			e.printStackTrace();
			tx.rollback();
		}
		finally
		{
			//session.close();//与本地线程绑定的session，不需要手动关闭
			//sessionfactory.close();
		}		
	}

 

四、hibernate常用对象api的使用：

1、Query对象：

①使用query对象，不需要写sql语句，但是要写hql语句。

Hql:hibernate query language,hibernate提供查询语句，与sql相似。

②hql和sql语句区别：

Sql语句操作表和表字段；hql语句操作实体类和属性。

③查询所有hql语句：from 实体类名称

④Query对象使用

–创建Query对象；

–调用query对象里面的方法得到结果。

2.Criteria对象：

①使用这个对象查询操作，不需要写语句，直接调用方法实现

②实现过程：

–创建criteria对象；

–调用对象里面的方法得到结果。

3、SQLQuery对象：

①使用hibernate时候，调用底层sql实现；

②实现过程：

–创建SQLQuery对象；

–调用对象的方法。

 

4、代码实现：

	//使用Query对象
	@Test
	public void testQuery(){

		SessionFactory sessionfactory = null;
		Session session = null;
		Transaction tx=null;
		
		try{
			sessionfactory=HibernateUtil.getSessionFactory();
			session=sessionfactory.openSession();
			tx=session.beginTransaction();
			
			//1.创建Query对象，方法里面写hql语句
			Query query=session.createQuery("from User");
			//2.调用query对象的方法
			List<User> list=query.list();
			
			for(User user:list){
				System.out.println(user.toString());
			}
			
			tx.commit();
		}catch(Exception e){
			e.printStackTrace();
			tx.rollback();
		}
		finally{
			session.close();
			sessionfactory.close();
		}		
	}
	
	//使用Criteria对象
	@Test
	public void testCriteria(){
		SessionFactory sessionfactory = null;
		Session session = null;
		Transaction tx=null;
		
		try{
			sessionfactory=HibernateUtil.getSessionFactory();
			session=sessionfactory.openSession();
			tx=session.beginTransaction();
			
			//1.创建Criteria对象,参数写类名
			Criteria criteria=session.createCriteria(User.class);
			//2.调用criteria对象的方法
			List<User> list=criteria.list();
			
			for(User user:list){
				System.out.println(user.toString());
			}
			
			tx.commit();
		}catch(Exception e){
			e.printStackTrace();
			tx.rollback();
		}
		finally{
			session.close();
			sessionfactory.close();
		}		
	}
	
	//使用SQLQuery对象
	@Test
	public void testSQLQuery(){
		SessionFactory sessionfactory = null;
		Session session = null;
		Transaction tx=null;
		
		try{
			sessionfactory=HibernateUtil.getSessionFactory();
			session=sessionfactory.openSession();
			tx=session.beginTransaction();
			
			//1.创建SQLQuery对象,参数写底层sql语句
			SQLQuery sqlquery=session.createSQLQuery("select * from t_user");
			
			//调用SQLQuery对象的方法
			//2.1 list默认返回的是数组的形式
/*			List<Object[]> list=sqlquery.list();
			for(Object[] objects:list){
				//System.out.println(objects);
				System.out.println(Arrays.toString(objects));
			}*/
			
			//2.2设置返回的是对象的形式：
			sqlquery.addEntity(User.class);
			//调用SQLQuery对象的方法
			List<User> list =sqlquery.list();
			
			for(User user:list){
				System.out.println(user.toString());
			}
			
			tx.commit();
		}catch(Exception e){
			e.printStackTrace();
			tx.rollback();
		}
		finally
		{
			session.close();
			sessionfactory.close();
		}		
	}

 

五、hibernate缓存：

一级缓存：

（1）一级缓存是默认打开的；

（2）一级缓存作用范围，是从session创建到session关闭；

（3）一级缓存存储的数据，必须是持久态数据。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/114723.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

  • initramfs-kernel_deepin initramfs

    initramfs-kernel_deepin initramfs

    initramfs-kernel_deepin initramfsOtherlanguages:一些基于Linux的计算机系统系统需要一个intramfs才能正常启动。在本指南中，将说明initramfs的概念，以及如何正确地创建和管理initramfs。Initramfs是什么介绍许多用户是没有必要关心initramfs系统的。他们的系统使用了简单的分区方案，而且没有奇奇怪怪的驱动程序或者设置(如加密的文件系统)，因此Linux内核完全能够把…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年8月11日
  • SQL Server 2008备份数据库失败，拒绝访问的原因

    SQL Server 2008备份数据库失败，拒绝访问的原因

    SQL Server 2008备份数据库失败，拒绝访问的原因

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年8月28日
  • 树：二叉树的层序遍历算法（超简洁实现及详细分析）

    树：二叉树的层序遍历算法（超简洁实现及详细分析）

    树：二叉树的层序遍历算法（超简洁实现及详细分析）实现思路我们来看看下图的二叉链表如何实现层序遍历。层序遍历顺序：ABECDGA为B、E的双亲结点，遍历顺序是根-&gt;左-&gt;右是不是。而且每个结点都是这样的遍历顺序有木有。那么我们完全可以采用队列的数据结构呗。A入队-&gt;然后出队，出队时将其左右孩子入队，循环队列进行出队，每次出队将其左右孩子入队。当队列为空时，整棵树层序遍历完毕。还没明白请看下面过程。A-&g…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年5月21日
  • 富文本编辑器汇总_移动端富文本编辑器

    富文本编辑器汇总_移动端富文本编辑器

    富文本编辑器汇总_移动端富文本编辑器富文本编辑器：（RichTextEditor，RTE）是一种可内嵌于浏览器，所见即所得的文本编辑器。它提供类似于OfficeWord的编辑功能，方便那些不太懂HTML用户使用，富文本编辑器的应用非常广泛，它的历史与图文网页诞生的历史几乎一样长。1.TinyMCTinyMCE是一个开源的所见即所得的HTML编辑器，界面相当清新，界面模拟本地软件的风格，顶部有菜单栏。支持图片在线处理，插件多，功能非常强大，易于集成，并且拥有可定制的主题。支持目前流行的各种浏览器，它可以达到微软…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月29日
  • 路由器下一跳地址怎么判断_一篇文章，了解清楚路由器的各种组网「建议收藏」

    路由器下一跳地址怎么判断_一篇文章，了解清楚路由器的各种组网「建议收藏」

    很多朋友问到，不同网段的两个电脑如何实现互访？这个通常在企业办公中会遇到，我们今天来看下。我们经常会遇到企业随着员工或部门的增多，增加了一个路由器，分了两个网段，A子网和B子网处于不同网段，当网络中存在多个路由器时，要求不同路由器下属的子网可以互相通讯，同时又可以通过宽带路由器上网，这如何实现？本期我们通过路由器的操作，来实现三种案例情况。案例情景1企业通过一台路由器R1上网，局域网LAN1,。因…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年4月16日
  • LOJ10049_基金012498

    LOJ10049_基金012498

    LOJ10049_基金012498LOJ10049Trie裸题（虽然我写这SB题写了快一小时）对字符串建树的同时刷答案，有两种情况：经过了一个字符串的词尾（即过了一个标记点）一直在另一个字符串里走（没有让树长出新枝）#include&lt;bits/stdc++.h&gt;#definegt()(p1==p2&amp;&amp;(p2=(p1=buf)+fread(buf,1,1000000,std…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月1日

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号