<span>Spring5学习笔记——day06</span>

文章目录

Spring

参考视频：B站狂神，写这个只是方便个人复习，怎么写是我自己的事，我能看懂就行，没要求非要让你看！白嫖还挑刺，是很没有风度的事情。希望做个有风度的“五好青年”！

12、整合MyBatis

步骤：

  • 导入相关jar包

    • junit 
            <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    • mybatis 
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.3</version>
</dependency>

  • mysql数据库

            <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

  • spring相关

            <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.12.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.10.RELEASE</version>
        </dependency>

  • AOP 织入器

          <dependency>
              <groupId>org.aspectj</groupId>
              <artifactId>aspectjweaver</artifactId>
              <version>1.9.6</version>
          </dependency>
  • mybatis-spring【整合包】 
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.6</version>
</dependency>

  • 配置Maven静态资源过滤问题！

      <build>
     <resources>
         <resource>
             <directory>src/main/java</directory>
             <includes>
                 <include>**/*.properties</include>
                 <include>**/*.xml</include>
             </includes>
             <filtering>true</filtering>
         </resource>
     </resources>
  </build>

  • 编写配置文件

  • 测试

12.1 回忆MyBatis

  1. 编写实体类 
package com.github.subei.pojo;

import lombok.Data;

@Data
public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}
  1. 编写MyBatis核心配置文件 
<?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核心配置文件-->
<configuration>

    <typeAliases>
        <package name="com.github.subei.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <package name="com.github.subei.mapper"/>
    </mappers>
    
</configuration>
  1. 编写接口 
package com.github.subei.mapper.mapper;

import com.github.subei.pojo.User;

import java.util.List;

public interface UserMapper {
    public List<User> selectUser();
}
  1. 编写Mapper.xml 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.github.subei.mapper.mapper.UserMapper">

    <select id="selectUser" resultType="user">
        select * from user;
    </select>

</mapper>
  1. 测试类 
import com.github.subei.mapper.mapper.UserMapper;
import com.github.subei.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MyTest {
    @Test
    public void selectUser() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        List<User> userList = mapper.selectUser();
        for(User user : userList){
            System.out.println(user);
        }

        sqlSession.close();
    }
}

12.2 MyBatis-Spring学习

什么是 MyBatis-Spring？

  • MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。

知识基础

  • 在开始使用 MyBatis-Spring 之前，你需要先熟悉 Spring 和 MyBatis 这两个框架和有关它们的术语。这很重要

MyBatis-Spring 需要以下版本：

MyBatis-Spring MyBatis Spring 框架 Spring Batch Java
2.0 3.5+ 5.0+ 4.0+ Java 8+
1.3 3.4+ 3.2.2+ 2.1+ Java 6+

如果使用 Maven 作为构建工具，仅需要在 pom.xml 中加入以下代码即可：

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>

  • 要和 Spring 一起使用 MyBatis，需要在 Spring 应用上下文中定义至少两样东西：一个 SqlSessionFactory 和至少一个数据映射器类。

  • 在 MyBatis-Spring 中，可使用SqlSessionFactoryBean来创建 SqlSessionFactory。 要创建工厂 bean，将下面的代码放到 Spring 的 XML 配置文件中：

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <property name="dataSource" ref="dataSource" />
</bean>

  • SqlSessionFactory需要一个 DataSource（数据源）。这可以是任意的 DataSource，只需要和配置其它 Spring 数据库连接一样配置它就可以了。

  • 在基础的 MyBatis 用法中，是通过 SqlSessionFactoryBuilder 来创建 SqlSessionFactory 的。而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来创建。

  • 在 MyBatis 中，你可以使用 SqlSessionFactory 来创建 SqlSession。一旦你获得一个 session 之后，你可以使用它来执行映射了的语句，提交或回滚连接，最后，当不再需要它的时候，你可以关闭 session。

  • SqlSessionFactory 有一个唯一的必要属性：用于 JDBC 的 DataSource。这可以是任意的 DataSource 对象，它的配置方法和其它 Spring 数据库连接是一样的。

  • 一个常用的属性是 configLocation，它用来指定 MyBatis 的 XML 配置文件路径。它在需要修改 MyBatis 的基础配置非常有用。通常，基础配置指的是**< settings>** 或 **< typeAliases>**元素。

  • 需要注意的是，这个配置文件并不需要是一个完整的 MyBatis 配置。确切地说，任何环境配置（），数据源（）和 MyBatis 的事务管理器（）都会被忽略。SqlSessionFactoryBean 会创建它自有的 MyBatis 环境配置（Environment），并按要求设置自定义环境的值。

  • SqlSessionTemplate 是 MyBatis-Spring 的核心。作为 SqlSession 的一个实现，这意味着可以使用它无缝代替你代码中已经在使用的 SqlSession。 SqlSessionTemplate 是线程安全的，可以被多个 DAO 或映射器所共享使用。

  • 当调用 SQL 方法时（包括由 getMapper() 方法返回的映射器中的方法），SqlSessionTemplate 将会保证使用的 SqlSession 与当前 Spring 的事务相关。 此外，它管理 session 的生命周期，包含必要的关闭、提交或回滚操作。另外，它也负责将 MyBatis 的异常翻译成 Spring 中的 DataAccessExceptions。

  • 由于模板可以参与到 Spring 的事务管理中，并且由于其是线程安全的，可以供多个映射器类使用，你应该总是用 SqlSessionTemplate 来替换 MyBatis 默认的 DefaultSqlSession 实现。在同一应用程序中的不同类之间混杂使用可能会引起数据一致性的问题。

  • 可以使用 SqlSessionFactory 作为构造方法的参数来创建 SqlSessionTemplate 对象。

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
  <constructor-arg index="0" ref="sqlSessionFactory" />
</bean>
  • 现在，这个 bean 就可以直接注入到你的 DAO bean 中了。你需要在你的 bean 中添加一个 SqlSession 属性，就像下面这样： 
public class UserDaoImpl implements UserDao {

  private SqlSession sqlSession;

  public void setSqlSession(SqlSession sqlSession) {
    this.sqlSession = sqlSession;
  }

  public User getUser(String userId) {
    return sqlSession.selectOne("org.mybatis.spring.sample.mapper.UserMapper.getUser", userId);
  }
}
  • 按下面这样，注入 SqlSessionTemplate： 
<bean id="userDao" class="org.mybatis.spring.sample.dao.UserDaoImpl">
  <property name="sqlSession" ref="sqlSession" />
</bean>

12.3 整合实现一

  1. 引入Spring配置文件spring-dao.xml。 
<?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" 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">
  1. 配置数据源替换mybaits的数据源，spring-dao.xml文件 
    <!-- DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid -->
    <!-- 我们这里使用spring是供JDBC:org.springframework.jdbc.datasource -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
  1. 配置SqlSessionFactory，关联MyBatis，spring-dao.xml文件 
    <!-- sqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 绑定mybatis配置文件 -->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/github/subei/mapper/mapper/*.xml"/>
    </bean>
  1. 注册sqlSessionTemplate，关联sqlSessionFactory；spring-dao.xml文件 
    <!-- SqlSessionTemplate:就是我们使用的sqLSession -->
    <bean id="SqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!-- 只能使用构造器注入sqlSessionFactory，因为它没有set方法 -->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
  1. 增加Dao接口的实现类；私有化sqlSessionTemplate，UserMapperImpl.java文件 
package com.github.subei.mapper.mapper;

import com.github.subei.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

public class UserMapperImpl implements UserMapper{

    // 我们的所有操作，都使用sqlSession来执行，在原来，现在都使用SqlSessionTemplate；
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();

    }
}
  1. 注册bean实现，applicationContext.xml文件 
<?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" 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">

    <import resource="spring-dao.xml"/>

    <!-- -->
    <bean id="userMapper" class="com.github.subei.mapper.mapper.UserMapperImpl">
        <property name="sqlSession" ref="SqlSession"/>
    </bean>

</beans>
  1. 测试 
import com.github.subei.mapper.mapper.UserMapper;
import com.github.subei.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MyTest {
    @Test
    public void selectUser() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.selectUser()){
            System.out.println(user);
        }
    }
}

  • 结果成功输出！现在我们的Mybatis配置文件的状态！发现都可以被Spring整合！mybatis-config.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核心配置文件-->
<configuration>

    <typeAliases>
        <package name="com.github.subei.pojo"/>
    </typeAliases>

    <!-- 设置 -->

    
</configuration>

12.4 整合实现二

mybatis-spring1.2.3版以上的才有这个。

  • dao继承Support类，直接利用 getSqlSession() 获得，然后直接注入SqlSessionFactory。比起方式1，不需要管理SqlSessionTemplate , 而且对事务的支持更加友好。可跟踪源码查看！！！

测试：

  1. 将上面写的UserMapperImpl.java修改一下 
package com.github.subei.mapper.mapper;

import com.github.subei.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{

    public List<User> selectUser() {
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}
  1. 修改bean的配置 
    <bean id="userMapper2" class="com.github.subei.mapper.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
    </bean>
  1. 测试 
import com.github.subei.mapper.mapper.UserMapper;
import com.github.subei.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MyTest {
    @Test
    public void selectUser() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
        for (User user : userMapper.selectUser()){
            System.out.println(user);
        }
    }
}

总结 : 整合到spring以后可以完全不要mybatis的配置文件，除了这些方式可以实现整合之外，还可以使用注解来实现！

13、声明式事务

13.1 回顾事务

  • 把一组业务当成一个业务来做；要么都成功，要么都失败！
  • 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
  • 确保完整性和一致性；

事务就是把一系列的动作当成一个独立的工作单元，这些动作要么全部完成，要么全部不起作用。

  • 事务的ACID原则

  1. 原子性（atomicity）

    • 事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用。

  2. 一致性（consistency）

    • 一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中。

  3. 隔离性（isolation）

    • 可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。

  4. 持久性（durability）

    • 事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中。

13.2 测试

将上面的代码拷贝到一个新项目中：

  • 在之前的案例中，在userDao接口新增两个方法，删除和增加用户； 
package com.github.subei.mapper;

import com.github.subei.pojo.User;

import java.util.List;

public interface UserMapper {
    public List<User> selectUser();

    // 添加一个用户
    public int addUser(User user);

    // 根据id删除用户
    public int deleteUser(int id);
}
  • UserMapper.xml文件，故意把 deletes 写错，用于测试！ 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.github.subei.mapper.UserMapper">

    <select id="selectUser" resultType="user">
        select * from user;
    </select>

    <insert id="addUser" parameterType="com.kuang.pojo.User">
        insert into user (id,name,pwd) values (#{id},#{name},#{pwd});
    </insert>

    <delete id="deleteUser" parameterType="int">
        deletes from user where id = #{id};
    </delete>

</mapper>
  • 编写接口的实现类UserMapperImpl.java文件 
package com.github.subei.mapper;

import com.github.subei.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper{

    // 增加一些操作
    public List<User> selectUser() {
        User user = new User(6,"维维","123456");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.addUser(user);
        mapper.deleteUser(6);
        return mapper.selectUser();
    }

    public int addUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).addUser(user);
    }

    public int deleteUser(int id) {
        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
    }
}
  • 测试类 
import com.github.subei.mapper.UserMapper;
import com.github.subei.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.util.List;

public class MyTest {
    @Test
    public void selectUser() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationCon.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);

        List<User> userList = userMapper.selectUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

  • 报错：sql异常，delete写错了。结果 ：插入成功！

13.3 Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

编程式事务管理

  • 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
  • 缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

声明式事务管理==(交由容器管理事务)

  • 一般情况下比编程式事务好用。
  • 将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
  • 将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。
  • 配置声明式事务 
    <!-- 配置声明式事务 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
  • 使用Spring管理事务，注意头文件的约束导入 : tx
       xmlns:tx="http://www.springframework.org/schema/tx"

        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
  • 配置好事务管理器后，去配置事务的通知 
    <!-- 结合AOP实现事物的织入 -->
    <!-- 配置事务的通知: -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 配置哪些方法使用什么样的事务,配置事务的传播特性 -->
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="search*" propagation="REQUIRED"/>
            <tx:method name="get" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
  • spring事务传播特性：

事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：

  • propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
  • propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
  • propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
  • propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
  • propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  • propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
  • propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作

Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。

  • 配置AOP
    • 导入aop的头文件！ 
    <!-- 配置事务的切入 -->
    <aop:config>
        <aop:pointcut id="txPointcut" expression="execution(* com.github.subei.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    </aop:config>
  • 进行测试
    • <mark>删掉刚才插入的数据</mark>，再次测试！ 
import com.github.subei.mapper.UserMapper;
import com.github.subei.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.util.List;

public class MyTest {
    @Test
    public void selectUser() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationCon.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);

        List<User> userList = userMapper.selectUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

为什么需要配置事务？

  • 如果不配置事务，可能存在数据提交不一致的情况下；
  • 如果我们不在SPRING中去配置声明式事务，就需要手动提交控制事务；
  • 事务在项目开发过程非常重要，涉及到数据的一致性的问题，不容马虎！

🎉🎉🎉完结撒花🎉🎉🎉

全部评论

相关推荐

昨天 14:55
小红书_社区技术部_前端开发(实习员工)
9.24古茗一面
今年没想到卷成这样，面试表现挺好的，但是问多久出结果，说是候选人特别多，可能要很久，然后就一直没给后续，估计是进池子了。自我介绍如何了解到的我们公司心动的复杂权限场景以及性能优化，按钮权限，菜单权限，接口权限都是怎么实现的ci/cd是什么大文件的分片上传怎么实现的如何保证每一片的完整性文件传输某一片失败的该怎么办为什么这样子设计介绍一下promisetry&nbsp;catch能否监听到promise的错误，为什么promise.race的特点promise还有什么方法hash路由与history路由的区别为什么history需要服务端配置入口地址小程序开发的了解前端浏览器缓存mvc和mvvm是什么什么...
查看26道真题和解析 面经烤面筋
点赞 评论 收藏
分享
昨天 09:35
北京理工大学 Java
说说字节两年工作体验
一开始字节的氛围还不错，大家都在努力推动&nbsp;TikTok&nbsp;的国际化，翻译文档、说英语，甚至还成立了各种小组来解决沟通问题，感觉一切都在朝着好的方向发展。不过，后面就开始变味了。文档永远跟不上，大家觉得写文档浪费时间，结果就是你得自己去找人问，很多时候人家根本不理你。还有就是公司文化，管理层和普通员工之间的距离感太大了，完全不顾员工的工作体验。大家都在拼命追求结果，根本不在乎你是否累得脱发、婚姻危机。每次你需要支持的时候，经理们总是让你自己去找人。同事之间的关系也很微妙，大家为了自保，第一反应就是投诉和甩锅，完全没有合作的氛围。
字节跳动公司氛围 539人发布
点赞 评论 收藏
分享
10-18 20:30
西安电子科技大学 Java
爱华，信华，等华！
喜欢走神的孤勇者练习时长两年半：爱华，信华，等华，黑华
点赞 评论 收藏
分享
10-30 22:18
已编辑
毛坦厂中学 C++
点赞 评论 收藏
分享
昨天 15:10
华南理工大学 Java
点赞 评论 收藏
分享
点赞 收藏 评论
分享

全站热榜

正在热议
# 25届秋招总结 #
273658次浏览 2327人参与
# 如果实习可以转正，你会不会放弃秋招 #
205525次浏览 2799人参与
# 北方华创开奖 #
24186次浏览 262人参与
# 地方国企笔面经互助 #
3103次浏览 7人参与
# 学历or实习经历，哪个更重要 #
46147次浏览 357人参与
# 选完offer后，你后悔学本专业吗 #
15653次浏览 117人参与
# 如何一边实习一边秋招 #
988424次浏览 12618人参与
# 数据人的面试交流地 #
435942次浏览 7810人参与
# 0offer是寒冬太冷还是我太菜 #
891089次浏览 7954人参与
# 得物求职进展汇总 #
64432次浏览 669人参与
# 软开人，秋招你打算投哪些公司呢 #
41057次浏览 530人参与
# 你觉得专业和学校哪个对薪资影响最大 #
28705次浏览 215人参与
# 查收我的offer竞争力报告 #
20755次浏览 261人参与
# 你最想要的公司福利是？ #
42949次浏览 156人参与
# 来聊聊机械薪资天花板是哪家 #
67007次浏览 453人参与
# 当你面对裁员会如何？ #
26369次浏览 154人参与
# 应届生被毁约被毁意向了怎么办 #
28685次浏览 244人参与
# 一觉醒来，我觉醒了超级打工人系统 #
3492次浏览 36人参与
# 没有实习经历，还有机会进大厂吗 #
808284次浏览 13872人参与
# 面试体验感最好的是哪家？ #
84001次浏览 820人参与
# 机械应届生薪资要多少才合适？ #
12607次浏览 61人参与
牛客网
牛客企业服务