这是一个员工绩效考核系统的需求描述，涉及到的技术栈包括Java, Spring Boot, MyBatis, Vue, Element UI以及MySQL。

首先，我们需要定义项目的需求和功能，例如：

• 员工登录和权限管理
• 绩效考核指标管理（例如KPI指标、绩效评估等）
• 绩效数据录入和审核
• 绩效评估报告生成
• 数据可视化和分析（图表、报表等）

接下来，我们可以创建数据库和表，例如：

CREATE TABLE `employee` (
  `id` INT NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(50) NOT NULL,
  `email` VARCHAR(50),
  -- 其他员工信息字段
  PRIMARY KEY (`id`)
);
 
CREATE TABLE `performance` (
  `id` INT NOT NULL AUTO_INCREMENT,
  `employee_id` INT NOT NULL,
  `quarter` INT NOT NULL,
  `performance_data` TEXT,
  -- KPI指标等字段
  PRIMARY KEY (`id`)
);

然后，我们可以使用Spring Boot创建后端API，例如：

@RestController
@RequestMapping("/api/v1/performances")
public class PerformanceController {
    @Autowired
    private PerformanceService performanceService;
 
    @PostMapping
    public ResponseEntity<Performance> createPerformance(@RequestBody Performance performance) {
        return new ResponseEntity<>(performanceService.createPerformance(performance), HttpStatus.CREATED);
    }
 
    // 其他API方法，例如获取绩效数据等
}

接下来，我们可以使用Vue和Element UI创建前端界面，例如：

<template>
  <el-form ref="form" :model="form" label-width="120px">
    <el-form-item label="员工名称">
      <el-input v-model="form.name" />
    </el-form-item>
    <!-- 其他表单字段 -->
    <el-form-item>
      <el-button type="primary" @click="submitForm">提交</el-button>
    </el-form-item>
  </el-form>
</template>
 
<script>
export default {
  data() {
    return {
      form: {
        name: '',
        // 其他字段
      }
    };
  },
  methods: {
    submitForm() {
      this.$http.post('/api/v1/performances', this.form)
        .then(response => {
          // 处理响应
        })
        .catch(error => {
          // 处理错误
        });
    }
  }
};
</script>

最后，我们需要配置Spring Boot应用，使其能够连接MySQL数据库，并且配置Vue项目，使其能够与后端API进行通信。

这个项目是一个简化版的示例，实际项目中还需要考虑更多的细节，例如权限管理、异常处理、分页、搜索、排序等功能。

在Java中，可以使用Stream API来获取List中指定索引位置的元素或者最后一个元素。以下是两种情况的示例代码：

1. 获取指定索引位置的元素：

import java.util.List;
import java.util.Optional;
 
public class Main {
    public static void main(String[] args) {
        List<String> list = List.of("a", "b", "c", "d");
        int index = 2; // 指定索引位置
 
        Optional<String> element = list.stream().skip(index).findFirst();
        element.ifPresent(System.out::println); // 输出 c
    }
}

2. 获取最后一个元素：

import java.util.List;
import java.util.Optional;
 
public class Main {
    public static void main(String[] args) {
        List<String> list = List.of("a", "b", "c", "d");
 
        Optional<String> lastElement = list.stream().reduce((first, second) -> second);
        lastElement.ifPresent(System.out::println); // 输出 d
    }
}

在第一个例子中，skip(index) 方法用于跳过指定数量的元素，然后 findFirst() 返回第一个元素（即索引位置之后的第一个元素）。

在第二个例子中，reduce() 方法用于将流中的元素归约为一个值，传递给reduction函数的参数是流中的连续两个元素，该函数返回的值会在下一次迭代中作为第一个参数，直到流中的最后一个元素，在这个例子中我们返回最后一个元素作为结果。

该代码实例涉及到的技术栈包括Java、Spring Boot、MyBatis、Vue.js和Element UI。由于篇幅限制，我将提供核心配置和部分关键代码。

核心配置

1. 数据库配置：在application.properties中配置MySQL数据库连接信息。

spring.datasource.url=jdbc:mysql://localhost:3306/hospital_numbering?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

2. Spring Boot配置：启动类上添加@MapperScan注解扫描MyBatis接口。

@SpringBootApplication
@MapperScan("com.example.mapper")
public class HospitalNumberingApplication {
    public static void main(String[] args) {
        SpringApplication.run(HospitalNumberingApplication.class, args);
    }
}

关键代码

1. 控制器（Controller）部分：处理HTTP请求。

@RestController
@RequestMapping("/api/patient")
public class PatientController {
    @Autowired
    private PatientService patientService;
 
    @PostMapping("/register")
    public Result register(@RequestBody Patient patient) {
        return patientService.register(patient);
    }
 
    // 其他控制器方法
}

2. 服务层（Service）部分：业务逻辑处理。

@Service
public class PatientService {
    @Autowired
    private PatientMapper patientMapper;
 
    public Result register(Patient patient) {
        // 业务逻辑处理
        patientMapper.insert(patient);
        return Result.success("注册成功");
    }
 
    // 其他服务方法
}

3. MyBatis映射器（Mapper）部分：操作数据库。

@Mapper
public interface PatientMapper {
    int insert(Patient patient);
 
    // 其他映射方法
}

注意：以上代码仅为核心部分，实际系统中还会有更多的功能和细节。为了保证答案的简洁性，没有包含完整的代码。如果需要完整的代码，请联系系统的开发者或者提供者。

实现一个即时通讯管理系统涉及的技术栈较多，包括后端的Spring Boot框架、前端的Vue.js以及UI库Element UI，以下是一个基础的系统架构设计和代码示例：

后端（Spring Boot）:

1. 用户管理：包括用户注册、登录、用户信息修改等。
2. 好友管理：添加好友、查看好友列表、移除好友等。
3. 消息管理：发送文本消息、图片消息等。
4. WebSocket支持：使用Spring的WebSocket支持实现消息的实时推送。

后端代码示例（仅展示关键部分）:

@Controller
public class ChatController {
    private static final Set<WebSocketSession> sessions = Collections.synchronizedSet(new HashSet<>());
 
    @MessageMapping("/chat")
    @SendTo("/topic/public")
    public Message sendMessage(Message message) {
        return message;
    }
 
    @Autowired
    private SimpMessagingTemplate template;
 
    public void sendMessageToUser(String user, Message message) {
        template.convertAndSendToUser(user, "/queue/messages", message);
    }
 
    // WebSocket连接和关闭处理
    @Autowired
    private WebSocketConfig webSocketConfig;
 
    @Autowired
    private SimpMessagingTemplate messagingTemplate;
 
    @MessageMapping("/welcome")
    public void welcome(Principal principal, @Payload String message,
                        MessageHeaders headers, SimpMessageContext context) {
        // 用户登录后，将其添加到session集合中
        WebSocketSession session = context.getSession();
        sessions.add(session);
        // ...
    }
}

前端（Vue.js + Element UI）:

1. 登录页面：用户输入用户名和密码进行登录。
2. 好友列表：展示在线好友，可以发起聊天。
3. 消息输入区：用户输入文本和图片，发送给好友。
4. 消息展示区：展示收到和发送的消息。

前端代码示例（仅展示关键部分）:

<template>
  <el-row>
    <el-col :span="16" :offset="4">
      <el-input v-model="message" placeholder="请输入内容" />
      <el-button @click="sendMessage">发送</el-button>
      <div v-for="msg in messages" :key="msg.id" class="message">
        {{ msg.content }}
      </div>
    </el-col>
  </el-row>
</template>
 
<script>
export default {
  data() {
    return {
      message: '',
      messages: []
    };
  },
  methods: {
    sendMessage() {
      // 使用WebSocket发送消息
      this.$socket.send(JSON.stringify({ content: this.message }));
      this.message = '';
    }
  },
  sockets: {
    message(data) {
      this.messages.push(data);
    }
  }
};
</script>

以上代码仅为基础架构，实际项目中需要考虑更多安全性、可靠性和性能因素，如消息的加密、解密、存储、消息的送达保证、离线消息、群聊等功能。

校园外卖服务系统是一个涉及多方面的复杂项目，涉及到前后端的分离开发。以下是一些关键的技术栈和部分代码示例：

后端（Spring Boot + MyBatis）:

// 用户实体类
public class User {
    private Long id;
    private String username;
    private String password;
    // 省略其他属性、getter和setter方法
}
 
// UserMapper.java (MyBatis映射器)
public interface UserMapper {
    User selectByUsername(@Param("username") String username);
    int insert(User user);
    // 省略其他方法
}
 
// UserService.java (服务层)
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
 
    public User findUserByUsername(String username) {
        return userMapper.selectByUsername(username);
    }
 
    public void registerUser(User user) {
        userMapper.insert(user);
    }
    // 省略其他方法
}

前端（Vue + Element UI）:

// Vue组件中的登录方法
methods: {
    handleLogin() {
        this.$refs.loginForm.validate(valid => {
            if (valid) {
                this.loading = true;
                this.$http.post('/api/login', this.loginForm)
                    .then(response => {
                        // 登录成功处理逻辑
                        this.loading = false;
                        // 保存token和用户信息到本地
                        localStorage.setItem('token', response.data.token);
                        this.$router.push('/home');
                    })
                    .catch(() => {
                        this.loading = false;
                    });
            } else {
                console.log('表单验证失败！');
                return false;
            }
        });
    }
}

数据库设计（MySQL）:

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `password` varchar(50) NOT NULL,
  -- 省略其他字段
  PRIMARY KEY (`id`)
);
 
CREATE TABLE `order` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_id` bigint(20) NOT NULL,
  `dish_id` bigint(20) NOT NULL,
  `amount` int(11) NOT NULL,
  -- 省略其他字段
  PRIMARY KEY (`id`),
  KEY `user_id_idx` (`user_id`),
  KEY `dish_id_idx` (`dish_id`)
);

以上代码仅展示了部分关键代码，实际项目中还会涉及到更多的功能，如订单管理、餐品管理、支付等模块。由于篇幅限制，无法提供完整的代码和数据库设计。这个项目是一个很好的学习资源，可以帮助开发者理解如何构建一个完整的Web应用程序。

在Vue和Element UI中，可以使用el-input-number组件来限制用户输入。你可以使用@keydown事件来监听键盘事件，并编写逻辑来限制输入。

以下是一个简单的例子，展示了如何在el-input-number中使用键盘事件来限制输入：

<template>
  <el-input-number
    v-model="number"
    :min="1"
    :max="10"
    @keydown.native="handleKeyDown"
  ></el-input-number>
</template>
 
<script>
export default {
  data() {
    return {
      number: 1,
    };
  },
  methods: {
    handleKeyDown(event) {
      // 允许的按键
      const allowedKeys = [
        'Backspace', 'Delete', 'Tab', 'Escape', 'ArrowLeft', 'ArrowRight',
        'Meta', 'Control', 'Alt', 'Shift',
      ];
 
      // 如果是数字键盘的按键或不允许的按键，则阻止事件
      if (!(event.keyCode >= 48 && event.keyCode <= 57) && !allowedKeys.includes(event.key)) {
        event.preventDefault();
      }
    },
  },
};
</script>

在这个例子中，handleKeyDown方法会在用户按下键盘时被触发。我们检查按下的键是否是数字键（0-9），如果不是，我们还检查是否是允许的按键。如果不是数字也不是特定的按键，我们使用event.preventDefault()来阻止事件的默认行为，即阻止用户输入。这样就可以限制用户只能输入数字，并且可以自由使用箭头键进行增减操作。

由于提供的代码已经是一个完整的Spring Boot项目，并且涉及到的内容较多，我将提供一个核心的Spring Boot + Vue + Element UI的图书商城管理系统的登录页面示例。

后端（Spring Boot）:

// BookStoreController.java
@RestController
@RequestMapping("/api")
public class BookStoreController {
 
    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody LoginRequest request) {
        // 假设用户名和密码正确
        if ("admin".equals(request.getUsername()) && "password".equals(request.getPassword())) {
            return ResponseEntity.ok("登录成功");
        }
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("登录失败");
    }
}
 
// LoginRequest.java
public class LoginRequest {
    private String username;
    private String password;
 
    // getters and setters
}

前端（Vue + Element UI）:

<!-- login.vue -->
<template>
  <el-form ref="loginForm" :model="loginForm" label-width="80px">
    <el-form-item label="用户名">
      <el-input v-model="loginForm.username" autocomplete="off"></el-input>
    </el-form-item>
    <el-form-item label="密码">
      <el-input type="password" v-model="loginForm.password" autocomplete="off"></el-input>
    </el-form-item>
    <el-form-item>
      <el-button type="primary" @click="submitForm">登录</el-button>
    </el-form-item>
  </el-form>
</template>
 
<script>
export default {
  data() {
    return {
      loginForm: {
        username: '',
        password: ''
      }
    };
  },
  methods: {
    submitForm() {
      this.$http.post('/api/login', this.loginForm)
        .then(response => {
          console.log(response.data);
          // 登录成功后的逻辑，如保存token，跳转到首页等
        })
        .catch(error => {
          console.error('登录失败', error);
          // 登录失败的逻辑，如提示用户错误信息等
        });
    }
  }
};
</script>

在这个例子中，我们创建了一个简单的登录表单，并在Vue组件中定义了提交方法。当用户点击登录按钮时，会向后端的/api/login端点发送一个POST请求，并在成功登录后处理响应。

请注意，这只是一个非常基础的示例，实际的项目中还需要包含诸如路由守卫、状态管理、异常处理等功能。

由于篇幅所限，我将提供一个简化的学生求职招聘系统的核心模块设计和部分代码实现。

假设我们已经有了前端Vue组件和后端Spring控制器，以下是一个简化的学生求职招聘系统中发布招聘信息的后端服务设计和代码实现。

// 后端服务设计
@RestController
@RequestMapping("/api/recruitment")
public class RecruitmentController {
 
    @Autowired
    private RecruitmentService recruitmentService;
 
    // 发布招聘信息
    @PostMapping("/post")
    public ResponseEntity<?> postRecruitment(@Valid @RequestBody RecruitmentDto recruitmentDto) {
        Recruitment recruitment = recruitmentService.saveRecruitment(recruitmentDto);
        return ResponseEntity.ok(recruitment);
    }
}
 
// 服务层实现
@Service
public class RecruitmentService {
 
    @Autowired
    private RecruitmentRepository recruitmentRepository;
 
    public Recruitment saveRecruitment(RecruitmentDto recruitmentDto) {
        Recruitment recruitment = new Recruitment();
        // 转换Dto到实体
        recruitment.setPosition(recruitmentDto.getPosition());
        // ... 设置其他属性
        return recruitmentRepository.save(recruitment);
    }
}
 
// 实体映射
@Entity
public class Recruitment {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    private String position;
    // ... 其他属性
 
    // getters and setters
}
 
// Dto传输对象
public class RecruitmentDto {
    private String position;
    // ... 其他属性
 
    // getters and setters
}
 
// 仓库层
public interface RecruitmentRepository extends JpaRepository<Recruitment, Long> {
}

在这个简化的例子中，我们定义了一个后端的RecruitmentController来处理前端发送的招聘信息。我们使用了@Valid注解来确保Dto中的数据是有效的。服务层的RecruitmentService负责将Dto转换为实体并保存到仓库中。

这个例子展示了如何设计一个简单的后端服务来处理求职招聘信息的发布。在实际应用中，你需要考虑更多的细节，例如安全性、权限控制、异常处理等。

校园交友系统是一个典型的互动社交平台，它可以帮助学生和教师发现和接触新的朋友。以下是一个简化的代码示例，展示了如何使用Spring Boot创建一个简单的RESTful API接口，用于用户注册。

import org.springframework.web.bind.annotation.*;
 
@RestController
@RequestMapping("/api/v1/users")
public class UserController {
 
    // 假设这是用户服务层，实际开发中需要实现相关的业务逻辑
    // @Autowired
    // private UserService userService;
 
    // 用户注册接口
    @PostMapping("/register")
    public String registerUser(@RequestBody User user) {
        // 实际开发中，这里会调用userService的方法来处理业务逻辑
        // userService.registerUser(user);
 
        // 假设注册成功返回成功消息
        return "注册成功";
    }
 
    // 用户实体类
    public static class User {
        private String username;
        private String password;
        // 省略getter和setter方法
    }
}

在这个示例中，我们定义了一个UserController类，它有一个注册用户的接口/register。当客户端发送一个包含用户信息的POST请求到这个接口时，系统应该创建一个新的用户账号。在实际的应用中，你需要实现一个UserService层来处理业务逻辑，比如验证用户输入、保存用户信息到数据库等。

请注意，这只是一个简化的代码示例，实际的系统需要更复杂的安全措施、数据验证和错误处理。

这是一个基于JavaWeb和MySQL的Spring Boot家政服务管理平台的简化版本。以下是核心功能的代码示例：

实体类 (ServiceOrder.java):

@Entity
public class ServiceOrder {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String serviceName;
    private String serviceContent;
    private String serviceTime;
    // 省略getter和setter方法
}

Repository接口 (ServiceOrderRepository.java):

public interface ServiceOrderRepository extends JpaRepository<ServiceOrder, Long> {
    // 可以添加自定义查询方法
}

服务层 (ServiceOrderService.java):

@Service
public class ServiceOrderService {
    @Autowired
    private ServiceOrderRepository serviceOrderRepository;
 
    public List<ServiceOrder> findAll() {
        return serviceOrderRepository.findAll();
    }
 
    public ServiceOrder save(ServiceOrder serviceOrder) {
        return serviceOrderRepository.save(serviceOrder);
    }
 
    // 省略其他业务方法
}

控制器 (ServiceOrderController.java):

@RestController
@RequestMapping("/api/service-order")
public class ServiceOrderController {
    @Autowired
    private ServiceOrderService serviceOrderService;
 
    @GetMapping
    public ResponseEntity<List<ServiceOrder>> getAllServiceOrders() {
        List<ServiceOrder> serviceOrders = serviceOrderService.findAll();
        return ResponseEntity.ok(serviceOrders);
    }
 
    @PostMapping
    public ResponseEntity<ServiceOrder> createServiceOrder(@RequestBody ServiceOrder serviceOrder) {
        ServiceOrder savedServiceOrder = serviceOrderService.save(serviceOrder);
        return ResponseEntity.ok(savedServiceOrder);
    }
 
    // 省略其他控制器方法
}

这个简化的代码示例展示了如何使用Spring Data JPA和Spring Boot创建一个简单的家政服务管理平台的后端。实体类定义了数据模型，Repository接口继承自JpaRepository，用于简化数据库操作。服务层（Service）提供业务逻辑，控制器（Controller）处理HTTP请求。这个例子仅包含了最基本的功能，实际项目中还会有更多的细节，如安全控制、分页、过滤、异常处理等。