基于Spring Boot的邮件管理器系统，该系统可以部署在1Panel服务器上，以JAR包形式运行，并使用MySQL作为数据库存储邮件相关数据。系统将实现邮件的发送、接收、管理等功能，并提供用户友好的界面。

使用Spring Initializr创建一个新的Spring Boot项目，选择以下依赖：

<dependencies>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-mail</artifactId>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    
    
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <mainClass>com.example.mailmanager.MailManagerApplication</mainClass>
            </configuration>
        </plugin>
    </plugins>
</build>

# MySQL数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/mail_manager?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# JPA配置
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect

@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class EmailAccount {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String email;
    private String password;
    private String smtpHost;
    private Integer smtpPort;
    private String imapHost;
    private Integer imapPort;
    private Boolean active;
    private LocalDateTime createdAt;
}

@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class EmailMessage {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @ManyToOne
    private EmailAccount sender;
    
    private String recipients;
    private String subject;
    private String content;
    private LocalDateTime sentAt;
    private Boolean hasAttachment;
    private String status; // SENT, FAILED, DRAFT
}

@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
public class EmailTemplate {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    private String subject;
    private String content;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

@Service
@RequiredArgsConstructor
public class EmailService {
    private final JavaMailSender mailSender;
    private final TemplateEngine templateEngine;
    private final EmailAccountRepository emailAccountRepository;
    
    // 发送简单邮件
    public void sendSimpleEmail(String from, String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(from);
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
        mailSender.send(message);
    }
    
    // 发送HTML邮件
    public void sendHtmlEmail(String from, String to, String subject, String templateName, 
                            Context context) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true);
        
        String htmlContent = templateEngine.process(templateName, context);
        
        helper.setFrom(from);
        helper.setTo(to);
        helper.setSubject(subject);
        helper.setText(htmlContent, true);
        
        mailSender.send(message);
    }
    
    // 发送带附件的邮件
    public void sendEmailWithAttachment(String from, String to, String subject, String text, 
                                       String attachmentPath) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true);
        
        helper.setFrom(from);
        helper.setTo(to);
        helper.setSubject(subject);
        helper.setText(text);
        
        FileSystemResource file = new FileSystemResource(new File(attachmentPath));
        helper.addAttachment(file.getFilename(), file);
        
        mailSender.send(message);
    }
    
    // 异步发送邮件
    @Async
    public void sendAsyncEmail(String from, String to, String subject, String text) {
        sendSimpleEmail(from, to, subject, text);
    }
}

@Service
public class EmailReceiverService {
    public List<EmailMessage> receiveEmails(String username, String password, String host, 
                                          String protocol, int port) {
        List<EmailMessage> messages = new ArrayList<>();
        
        Properties props = new Properties();
        props.put("mail.store.protocol", protocol);
        props.put("mail." + protocol + ".host", host);
        props.put("mail." + protocol + ".port", port);
        props.put("mail." + protocol + ".ssl.enable", "true");
        
        try {
            Session session = Session.getInstance(props, null);
            Store store = session.getStore();
            store.connect(username, password);
            
            Folder inbox = store.getFolder("INBOX");
            inbox.open(Folder.READ_ONLY);
            
            Message[] emailMessages = inbox.getMessages();
            for (Message message : emailMessages) {
                EmailMessage emailMessage = convertToEmailMessage(message);
                messages.add(emailMessage);
            }
            
            inbox.close(false);
            store.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return messages;
    }
    
    private EmailMessage convertToEmailMessage(Message message) throws MessagingException, IOException {
        EmailMessage emailMessage = new EmailMessage();
        emailMessage.setSubject(message.getSubject());
        emailMessage.setContent(getTextFromMessage(message));
        emailMessage.setRecipients(Arrays.toString(message.getAllRecipients()));
        emailMessage.setSentAt(message.getSentDate().toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime());
        return emailMessage;
    }
    
    private String getTextFromMessage(Message message) throws MessagingException, IOException {
        if (message.isMimeType("text/plain")) {
            return message.getContent().toString();
        } else if (message.isMimeType("multipart/*")) {
            Multipart multipart = (Multipart) message.getContent();
            for (int i = 0; i < multipart.getCount(); i++) {
                BodyPart bodyPart = multipart.getBodyPart(i);
                if (bodyPart.isMimeType("text/plain")) {
                    return bodyPart.getContent().toString();
                }
            }
        }
        return "";
    }
}

# 邮件服务器配置
spring.mail.host=smtp.example.com
spring.mail.port=587
spring.mail.username=your_email@example.com
spring.mail.password=your_password
spring.mail.protocol=smtp
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
spring.mail.default-encoding=UTF-8

@Service
@RequiredArgsConstructor
public class EmailAccountService {
    private final EmailAccountRepository emailAccountRepository;
    
    public EmailAccount addEmailAccount(EmailAccount account) {
        account.setCreatedAt(LocalDateTime.now());
        account.setActive(true);
        return emailAccountRepository.save(account);
    }
    
    public List<EmailAccount> getAllActiveAccounts() {
        return emailAccountRepository.findByActive(true);
    }
    
    public void deactivateAccount(Long accountId) {
        emailAccountRepository.findById(accountId).ifPresent(account -> {
            account.setActive(false);
            emailAccountRepository.save(account);
        });
    }
    
    public JavaMailSender getMailSenderForAccount(Long accountId) {
        return emailAccountRepository.findById(accountId)
                .map(this::createMailSender)
                .orElseThrow(() -> new RuntimeException("Account not found"));
    }
    
    private JavaMailSender createMailSender(EmailAccount account) {
        JavaMailSenderImpl mailSender = new JavaMailSenderImpl();
        mailSender.setHost(account.getSmtpHost());
        mailSender.setPort(account.getSmtpPort());
        mailSender.setUsername(account.getEmail());
        mailSender.setPassword(account.getPassword());
        
        Properties props = mailSender.getJavaMailProperties();
        props.put("mail.transport.protocol", "smtp");
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.starttls.enable", "true");
        props.put("mail.debug", "true");
        
        return mailSender;
    }
}

@RestController
@RequestMapping("/api/emails")
@RequiredArgsConstructor
public class EmailController {
    private final EmailService emailService;
    private final EmailAccountService emailAccountService;
    private final EmailMessageRepository emailMessageRepository;
    
    @PostMapping("/send")
    public ResponseEntity<String> sendEmail(@RequestBody EmailRequest request) {
        try {
            emailService.sendSimpleEmail(request.getFrom(), request.getTo(), 
                                      request.getSubject(), request.getContent());
            
            // 保存发送记录
            EmailMessage message = new EmailMessage();
            message.setRecipients(request.getTo());
            message.setSubject(request.getSubject());
            message.setContent(request.getContent());
            message.setSentAt(LocalDateTime.now());
            message.setStatus("SENT");
            emailMessageRepository.save(message);
            
            return ResponseEntity.ok("Email sent successfully");
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("Failed to send email: " + e.getMessage());
        }
    }
    
    @PostMapping("/send-template")
    public ResponseEntity<String> sendTemplateEmail(@RequestBody TemplateEmailRequest request) {
        try {
            Context context = new Context();
            context.setVariables(request.getVariables());
            
            emailService.sendHtmlEmail(request.getFrom(), request.getTo(), 
                                     request.getSubject(), request.getTemplateName(), context);
            
            return ResponseEntity.ok("Template email sent successfully");
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("Failed to send template email: " + e.getMessage());
        }
    }
    
    @GetMapping("/received")
    public ResponseEntity<List<EmailMessage>> getReceivedEmails(
            @RequestParam Long accountId,
            @RequestParam(defaultValue = "imap") String protocol) {
        EmailAccount account = emailAccountService.getAccountById(accountId)
                .orElseThrow(() -> new RuntimeException("Account not found"));
        
        List<EmailMessage> messages = emailService.receiveEmails(
                account.getEmail(), 
                account.getPassword(), 
                account.getImapHost(), 
                protocol, 
                account.getImapPort());
        
        return ResponseEntity.ok(messages);
    }
}

@Data
class EmailRequest {
    private String from;
    private String to;
    private String subject;
    private String content;
}

@Data
class TemplateEmailRequest {
    private String from;
    private String to;
    private String subject;
    private String templateName;
    private Map<String, Object> variables;
}

@RestController
@RequestMapping("/api/accounts")
@RequiredArgsConstructor
public class EmailAccountController {
    private final EmailAccountService emailAccountService;
    
    @PostMapping
    public ResponseEntity<EmailAccount> addAccount(@RequestBody EmailAccount account) {
        return ResponseEntity.ok(emailAccountService.addEmailAccount(account));
    }
    
    @GetMapping
    public ResponseEntity<List<EmailAccount>> getAllAccounts() {
        return ResponseEntity.ok(emailAccountService.getAllActiveAccounts());
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deactivateAccount(@PathVariable Long id) {
        emailAccountService.deactivateAccount(id);
        return ResponseEntity.noContent().build();
    }
}

@Service
@RequiredArgsConstructor
public class EmailTemplateService {
    private final EmailTemplateRepository emailTemplateRepository;
    
    public EmailTemplate createTemplate(EmailTemplate template) {
        template.setCreatedAt(LocalDateTime.now());
        template.setUpdatedAt(LocalDateTime.now());
        return emailTemplateRepository.save(template);
    }
    
    public EmailTemplate updateTemplate(Long id, EmailTemplate template) {
        return emailTemplateRepository.findById(id)
                .map(existing -> {
                    existing.setName(template.getName());
                    existing.setSubject(template.getSubject());
                    existing.setContent(template.getContent());
                    existing.setUpdatedAt(LocalDateTime.now());
                    return emailTemplateRepository.save(existing);
                })
                .orElseThrow(() -> new RuntimeException("Template not found"));
    }
    
    public List<EmailTemplate> getAllTemplates() {
        return emailTemplateRepository.findAll();
    }
    
    public Optional<EmailTemplate> getTemplateById(Long id) {
        return emailTemplateRepository.findById(id);
    }
    
    public void deleteTemplate(Long id) {
        emailTemplateRepository.deleteById(id);
    }
}

@RestController
@RequestMapping("/api/templates")
@RequiredArgsConstructor
public class EmailTemplateController {
    private final EmailTemplateService emailTemplateService;
    
    @PostMapping
    public ResponseEntity<EmailTemplate> createTemplate(@RequestBody EmailTemplate template) {
        return ResponseEntity.ok(emailTemplateService.createTemplate(template));
    }
    
    @PutMapping("/{id}")
    public ResponseEntity<EmailTemplate> updateTemplate(
            @PathVariable Long id, @RequestBody EmailTemplate template) {
        return ResponseEntity.ok(emailTemplateService.updateTemplate(id, template));
    }
    
    @GetMapping
    public ResponseEntity<List<EmailTemplate>> getAllTemplates() {
        return ResponseEntity.ok(emailTemplateService.getAllTemplates());
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<EmailTemplate> getTemplateById(@PathVariable Long id) {
        return emailTemplateService.getTemplateById(id)
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteTemplate(@PathVariable Long id) {
        emailTemplateService.deleteTemplate(id);
        return ResponseEntity.noContent().build();
    }
}

在项目根目录下执行以下Maven命令打包项目：

这将生成一个可执行的JAR文件，通常位于

确保MySQL服务已在1Panel服务器上运行，并创建了

数据库。可以使用1Panel的数据库管理工具创建数据库和用户。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
                .antMatchers("/api/**").authenticated()
                .anyRequest().permitAll()
            .and()
            .httpBasic();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.setThreadNamePrefix("MailExecutor-");
        executor.initialize();
        return executor;
    }
}

@Service
public class EmailSenderWithRetry {
    private static final int MAX_RETRIES = 3;
    private static final long INITIAL_BACKOFF = 1000; // 1 second
    
    private final JavaMailSender mailSender;
    
    public EmailSenderWithRetry(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }
    
    public void sendWithRetry(SimpleMailMessage message) throws MailException {
        int attempt = 0;
        while (attempt < MAX_RETRIES) {
            try {
                mailSender.send(message);
                return;
            } catch (MailException e) {
                attempt++;
                if (attempt == MAX_RETRIES) {
                    throw e;
                }
                try {
                    long backoff = INITIAL_BACKOFF * (1 << (attempt - 1));
                    Thread.sleep(backoff);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new MailSendException("Interrupted during retry", ie);
                }
            }
        }
    }
}

@SpringBootTest
public class EmailServiceTest {
    
    @Autowired
    private EmailService emailService;
    
    @Test
    public void testSendSimpleEmail() {
        assertDoesNotThrow(() -> {
            emailService.sendSimpleEmail(
                "test@example.com", 
                "recipient@example.com", 
                "Test Subject", 
                "Test Content"
            );
        });
    }
    
    @Test
    public void testSendHtmlEmail() {
        Context context = new Context();
        context.setVariable("name", "John Doe");
        
        assertDoesNotThrow(() -> {
            emailService.sendHtmlEmail(
                "test@example.com", 
                "recipient@example.com", 
                "Test HTML Subject", 
                "email-template", 
                context
            );
        });
    }
}

@SpringBootTest
@AutoConfigureMockMvc
public class EmailControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Test
    public void testSendEmailEndpoint() throws Exception {
        EmailRequest request = new EmailRequest();
        request.setFrom("test@example.com");
        request.setTo("recipient@example.com");
        request.setSubject("Test Subject");
        request.setContent("Test Content");
        
        mockMvc.perform(post("/api/emails/send")
                .contentType(MediaType.APPLICATION_JSON)
                .content(new ObjectMapper().writeValueAsString(request)))
                .andExpect(status().isOk())
                .andExpect(content().string("Email sent successfully"));
    }
}

# Actuator配置
management.endpoints.web.exposure.include=health,info,metrics
management.endpoint.health.show-details=always
management.metrics.tags.application=mail-manager

@Component
public class EmailServiceHealthIndicator implements HealthIndicator {
    
    private final EmailService emailService;
    
    public EmailServiceHealthIndicator(EmailService emailService) {
        this.emailService = emailService;
    }
    
    @Override
    public Health health() {
        try {
            emailService.sendSimpleEmail(
                "healthcheck@example.com", 
                "healthcheck@example.com", 
                "Health Check", 
                "This is a health check email"
            );
            return Health.up().build();
        } catch (Exception e) {
            return Health.down()
                    .withDetail("error", e.getMessage())
                    .build();
        }
    }
}

本文详细介绍了如何开发一个基于Spring Boot的邮件管理器系统，包括系统设计、数据库配置、邮件服务实现、REST API设计、模板管理、系统部署到1Panel服务器等内容。该系统具有以下特点：

基于 Spring Boot 的邮件管理器系统代码

先锋会员

后端

数据库

开发工具

基于SpringBoot的邮件管理系统，支持多账户管理、邮件收发、模板发送等功能。系统采用MySQL存储数据，提供RESTful API接口，支持异步邮件发送和HTML模板，可轻松部署到1Panel服务器。集成SpringSecurity保障安全，是高效的企业级邮件管理解决方案。

数据库管理

单元测试

集成测试

系统测试

SQL数据库

应用管理

服务器

MySQL

AI驱动 智领未来

tencentdb-catalog

4核4G3M云服务器 新用户低至38元/年！

云数据库采购特惠，高性能、高可靠、高安全，超值优惠等你享！


文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

基于 Spring Boot 的邮件管理器系统代码

基于 Spring Boot 的邮件管理器系统代码

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐